#ifndef __DAO_FLTK_H__
#define __DAO_FLTK_H__
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<dao.h>
#include<FL/fl_types.h>
#include<FL/Enumerations.H>
#include<FL/Fl.H>
#include<FL/Fl_Adjuster.H>
#include<FL/Fl_BMP_Image.H>
#include<FL/Fl_Bitmap.H>
#include<FL/Fl_Box.H>
#include<FL/Fl_Browser.H>
#include<FL/Fl_Browser_.H>
#include<FL/Fl_Button.H>
#include<FL/Fl_Cairo.H>
#include<FL/Fl_Cairo_Window.H>
#include<FL/Fl_Chart.H>
#include<FL/Fl_Check_Browser.H>
#include<FL/Fl_Check_Button.H>
#include<FL/Fl_Choice.H>
#include<FL/Fl_Clock.H>
#include<FL/Fl_Color_Chooser.H>
#include<FL/Fl_Counter.H>
#include<FL/Fl_Device.H>
#include<FL/Fl_Dial.H>
#include<FL/Fl_Double_Window.H>
#include<FL/Fl_Export.H>
#include<FL/Fl_File_Browser.H>
#include<FL/Fl_File_Chooser.H>
#include<FL/Fl_File_Icon.H>
#include<FL/Fl_File_Input.H>
#include<FL/Fl_Fill_Dial.H>
#include<FL/Fl_Fill_Slider.H>
#include<FL/Fl_Float_Input.H>
#include<FL/Fl_FormsBitmap.H>
#include<FL/Fl_FormsPixmap.H>
#include<FL/Fl_Free.H>
#include<FL/Fl_GIF_Image.H>
#include<FL/Fl_Gl_Window.H>
#include<FL/Fl_Group.H>
#include<FL/Fl_Help_Dialog.H>
#include<FL/Fl_Help_View.H>
#include<FL/Fl_Hold_Browser.H>
#include<FL/Fl_Hor_Fill_Slider.H>
#include<FL/Fl_Hor_Nice_Slider.H>
#include<FL/Fl_Hor_Slider.H>
#include<FL/Fl_Hor_Value_Slider.H>
#include<FL/Fl_Image.H>
#include<FL/Fl_Input.H>
#include<FL/Fl_Input_.H>
#include<FL/Fl_Input_Choice.H>
#include<FL/Fl_Int_Input.H>
#include<FL/Fl_JPEG_Image.H>
#include<FL/Fl_Light_Button.H>
#include<FL/Fl_Line_Dial.H>
#include<FL/Fl_Menu.H>
#include<FL/Fl_Menu_.H>
#include<FL/Fl_Menu_Bar.H>
#include<FL/Fl_Menu_Button.H>
#include<FL/Fl_Menu_Item.H>
#include<FL/Fl_Menu_Window.H>
#include<FL/Fl_Multi_Browser.H>
#include<FL/Fl_Multi_Label.H>
#include<FL/Fl_Multiline_Input.H>
#include<FL/Fl_Multiline_Output.H>
#include<FL/Fl_Native_File_Chooser.H>
#include<FL/Fl_Nice_Slider.H>
#include<FL/Fl_Object.H>
#include<FL/Fl_Output.H>
#include<FL/Fl_Overlay_Window.H>
#include<FL/Fl_PNG_Image.H>
#include<FL/Fl_PNM_Image.H>
#include<FL/Fl_Pack.H>
#include<FL/Fl_Plugin.H>
#include<FL/Fl_Positioner.H>
#include<FL/Fl_Preferences.H>
#include<FL/Fl_Printer.H>
#include<FL/Fl_Progress.H>
#include<FL/Fl_RGB_Image.H>
#include<FL/Fl_Radio_Button.H>
#include<FL/Fl_Radio_Light_Button.H>
#include<FL/Fl_Radio_Round_Button.H>
#include<FL/Fl_Repeat_Button.H>
#include<FL/Fl_Return_Button.H>
#include<FL/Fl_Roller.H>
#include<FL/Fl_Round_Button.H>
#include<FL/Fl_Round_Clock.H>
#include<FL/Fl_Scroll.H>
#include<FL/Fl_Scrollbar.H>
#include<FL/Fl_Secret_Input.H>
#include<FL/Fl_Select_Browser.H>
#include<FL/Fl_Shared_Image.H>
#include<FL/Fl_Simple_Counter.H>
#include<FL/Fl_Single_Window.H>
#include<FL/Fl_Slider.H>
#include<FL/Fl_Spinner.H>
#include<FL/Fl_Sys_Menu_Bar.H>
#include<FL/Fl_Table.H>
#include<FL/Fl_Table_Row.H>
#include<FL/Fl_Tabs.H>
#include<FL/Fl_Text_Buffer.H>
#include<FL/Fl_Text_Display.H>
#include<FL/Fl_Text_Editor.H>
#include<FL/Fl_Tile.H>
#include<FL/Fl_Tiled_Image.H>
#include<FL/Fl_Timer.H>
#include<FL/Fl_Toggle_Button.H>
#include<FL/Fl_Toggle_Light_Button.H>
#include<FL/Fl_Toggle_Round_Button.H>
#include<FL/Fl_Tooltip.H>
#include<FL/Fl_Tree.H>
#include<FL/Fl_Tree_Item.H>
#include<FL/Fl_Tree_Item_Array.H>
#include<FL/Fl_Tree_Prefs.H>
#include<FL/Fl_Valuator.H>
#include<FL/Fl_Value_Input.H>
#include<FL/Fl_Value_Output.H>
#include<FL/Fl_Value_Slider.H>
#include<FL/Fl_Widget.H>
#include<FL/Fl_Window.H>
#include<FL/Fl_Wizard.H>
#include<FL/Fl_XBM_Image.H>
#include<FL/Fl_XPM_Image.H>
#include<FL/dirent.h>
#include<FL/filename.H>
#include<FL/fl_ask.H>
#include<FL/fl_draw.H>
#include<FL/fl_message.H>
#include<FL/fl_show_colormap.H>
#include<FL/fl_show_input.H>
#include<FL/fl_utf8.h>
#include<FL/forms.H>
#include<FL/gl.h>
#include<FL/gl2opengl.h>
#include<FL/gl_draw.H>
#include<FL/glu.h>
#include<FL/glut.H>
#include<FL/math.h>
#include<FL/names.h>
#ifndef DAO_FLTK_STATIC
#ifndef DAO_DLL_FLTK
#define DAO_DLL_FLTK DAO_DLL_EXPORT
#endif
#else
#define DAO_DLL_FLTK
#endif

extern DaoVmSpace *__daoVmSpace;

#ifdef __cplusplus
extern "C"{
#endif

extern DaoTypeBase *dao_FL_BLINE_Typer;
extern DaoTypeBase *dao_FL_CHART_ENTRY_Typer;
extern DaoTypeBase *dao_Fl_Widget_Typer;
extern DaoTypeBase *dao_Fl_Group_Typer;
extern DaoTypeBase *dao_Fl_Window_Typer;
extern DaoTypeBase *dao_Fl_Typer;
extern DaoTypeBase *dao_Fl_Device_Typer;
extern DaoTypeBase *dao_Fl_Abstract_Printer_Typer;
extern DaoTypeBase *dao_Fl_Abstract_Printer_chain_elt_Typer;
extern DaoTypeBase *dao_Fl_Valuator_Typer;
extern DaoTypeBase *dao_Fl_Adjuster_Typer;
extern DaoTypeBase *dao_Fl_Image_Typer;
extern DaoTypeBase *dao_Fl_RGB_Image_Typer;
extern DaoTypeBase *dao_Fl_BMP_Image_Typer;
extern DaoTypeBase *dao_Fl_Bitmap_Typer;
extern DaoTypeBase *dao_Fl_Box_Typer;
extern DaoTypeBase *dao_Fl_Browser__Typer;
extern DaoTypeBase *dao_Fl_Browser_Typer;
extern DaoTypeBase *dao_Fl_Button_Typer;
extern DaoTypeBase *dao_Fl_Chart_Typer;
extern DaoTypeBase *dao_Fl_Check_Browser_Typer;
extern DaoTypeBase *dao_Fl_Check_Browser_cb_item_Typer;
extern DaoTypeBase *dao_Fl_Light_Button_Typer;
extern DaoTypeBase *dao_Fl_Check_Button_Typer;
extern DaoTypeBase *dao_Fl_Menu__Typer;
extern DaoTypeBase *dao_Fl_Choice_Typer;
extern DaoTypeBase *dao_Fl_Clock_Output_Typer;
extern DaoTypeBase *dao_Fl_Clock_Typer;
extern DaoTypeBase *dao_Fl_Color_Chooser_Typer;
extern DaoTypeBase *dao_Fl_Counter_Typer;
extern DaoTypeBase *dao_Fl_Plugin_Typer;
extern DaoTypeBase *dao_Fl_Device_Plugin_Typer;
extern DaoTypeBase *dao_Fl_Dial_Typer;
extern DaoTypeBase *dao_Fl_Display_Typer;
extern DaoTypeBase *dao_Fl_Double_Window_Typer;
extern DaoTypeBase *dao_Fl_End_Typer;
extern DaoTypeBase *dao_Fl_File_Browser_Typer;
extern DaoTypeBase *dao_Fl_File_Chooser_Typer;
extern DaoTypeBase *dao_Fl_File_Icon_Typer;
extern DaoTypeBase *dao_Fl_Input__Typer;
extern DaoTypeBase *dao_Fl_Input_Typer;
extern DaoTypeBase *dao_Fl_File_Input_Typer;
extern DaoTypeBase *dao_Fl_Fill_Dial_Typer;
extern DaoTypeBase *dao_Fl_Slider_Typer;
extern DaoTypeBase *dao_Fl_Fill_Slider_Typer;
extern DaoTypeBase *dao_Fl_Float_Input_Typer;
extern DaoTypeBase *dao_Fl_FormsBitmap_Typer;
extern DaoTypeBase *dao_Fl_FormsPixmap_Typer;
extern DaoTypeBase *dao_Fl_FormsText_Typer;
extern DaoTypeBase *dao_Fl_Free_Typer;
extern DaoTypeBase *dao_Fl_Pixmap_Typer;
extern DaoTypeBase *dao_Fl_GIF_Image_Typer;
extern DaoTypeBase *dao_Fl_Gl_Window_Typer;
extern DaoTypeBase *dao_Fl_Glut_Bitmap_Font_Typer;
extern DaoTypeBase *dao_Fl_Glut_StrokeChar_Typer;
extern DaoTypeBase *dao_Fl_Glut_StrokeFont_Typer;
extern DaoTypeBase *dao_Fl_Glut_StrokeStrip_Typer;
extern DaoTypeBase *dao_Fl_Glut_StrokeVertex_Typer;
extern DaoTypeBase *dao_Fl_Glut_Window_Typer;
extern DaoTypeBase *dao_Fl_Help_Block_Typer;
extern DaoTypeBase *dao_Fl_Help_Dialog_Typer;
extern DaoTypeBase *dao_Fl_Help_Font_Stack_Typer;
extern DaoTypeBase *dao_Fl_Help_Font_Style_Typer;
extern DaoTypeBase *dao_Fl_Help_Link_Typer;
extern DaoTypeBase *dao_Fl_Help_Target_Typer;
extern DaoTypeBase *dao_Fl_Help_View_Typer;
extern DaoTypeBase *dao_Fl_Hold_Browser_Typer;
extern DaoTypeBase *dao_Fl_Hor_Fill_Slider_Typer;
extern DaoTypeBase *dao_Fl_Hor_Nice_Slider_Typer;
extern DaoTypeBase *dao_Fl_Hor_Slider_Typer;
extern DaoTypeBase *dao_Fl_Value_Slider_Typer;
extern DaoTypeBase *dao_Fl_Hor_Value_Slider_Typer;
extern DaoTypeBase *dao_Fl_Input_Choice_Typer;
extern DaoTypeBase *dao_Fl_Input_Choice_InputMenuButton_Typer;
extern DaoTypeBase *dao_Fl_Int_Input_Typer;
extern DaoTypeBase *dao_Fl_JPEG_Image_Typer;
extern DaoTypeBase *dao_Fl_Label_Typer;
extern DaoTypeBase *dao_Fl_Line_Dial_Typer;
extern DaoTypeBase *dao_Fl_Line_Position_Typer;
extern DaoTypeBase *dao_Fl_Menu_Item_Typer;
extern DaoTypeBase *dao_Fl_Menu_Bar_Typer;
extern DaoTypeBase *dao_Fl_Menu_Button_Typer;
extern DaoTypeBase *dao_Fl_Single_Window_Typer;
extern DaoTypeBase *dao_Fl_Menu_Window_Typer;
extern DaoTypeBase *dao_Fl_Multi_Browser_Typer;
extern DaoTypeBase *dao_Fl_Multi_Label_Typer;
extern DaoTypeBase *dao_Fl_Multiline_Input_Typer;
extern DaoTypeBase *dao_Fl_Output_Typer;
extern DaoTypeBase *dao_Fl_Multiline_Output_Typer;
extern DaoTypeBase *dao_Fl_Nice_Slider_Typer;
extern DaoTypeBase *dao_Fl_Overlay_Window_Typer;
extern DaoTypeBase *dao_Fl_PNG_Image_Typer;
extern DaoTypeBase *dao_Fl_PNM_Image_Typer;
extern DaoTypeBase *dao_Fl_PSfile_Device_Typer;
extern DaoTypeBase *dao_Fl_PSfile_Device_Clip_Typer;
extern DaoTypeBase *dao_Fl_PSfile_Device_page_format_Typer;
extern DaoTypeBase *dao_Fl_Pack_Typer;
extern DaoTypeBase *dao_Fl_Preferences_Typer;
extern DaoTypeBase *dao_Fl_Plugin_Manager_Typer;
extern DaoTypeBase *dao_Fl_Positioner_Typer;
extern DaoTypeBase *dao_Fl_Preferences_Entry_Typer;
extern DaoTypeBase *dao_Fl_Preferences_ID_Typer;
extern DaoTypeBase *dao_Fl_Preferences_Name_Typer;
extern DaoTypeBase *dao_Fl_Preferences_Node_Typer;
extern DaoTypeBase *dao_Fl_Preferences_RootNode_Typer;
extern DaoTypeBase *dao_Fl_Progress_Typer;
extern DaoTypeBase *dao_Fl_Radio_Button_Typer;
extern DaoTypeBase *dao_Fl_Radio_Light_Button_Typer;
extern DaoTypeBase *dao_Fl_Round_Button_Typer;
extern DaoTypeBase *dao_Fl_Radio_Round_Button_Typer;
extern DaoTypeBase *dao_Fl_Repeat_Button_Typer;
extern DaoTypeBase *dao_Fl_Return_Button_Typer;
extern DaoTypeBase *dao_Fl_Roller_Typer;
extern DaoTypeBase *dao_Fl_Round_Clock_Typer;
extern DaoTypeBase *dao_Fl_Scroll_Typer;
extern DaoTypeBase *dao_Fl_Scroll_ScrollInfo_Typer;
extern DaoTypeBase *dao_Fl_Scrollbar_Typer;
extern DaoTypeBase *dao_Fl_Secret_Input_Typer;
extern DaoTypeBase *dao_Fl_Select_Browser_Typer;
extern DaoTypeBase *dao_Fl_Shared_Image_Typer;
extern DaoTypeBase *dao_Fl_Simple_Counter_Typer;
extern DaoTypeBase *dao_Fl_Spinner_Typer;
extern DaoTypeBase *dao_Fl_Table_Typer;
extern DaoTypeBase *dao_Fl_Table_IntVector_Typer;
extern DaoTypeBase *dao_Fl_Table_Row_Typer;
extern DaoTypeBase *dao_Fl_Table_Row_CharVector_Typer;
extern DaoTypeBase *dao_Fl_Tabs_Typer;
extern DaoTypeBase *dao_Fl_Text_Buffer_Typer;
extern DaoTypeBase *dao_Fl_Text_Display_Typer;
extern DaoTypeBase *dao_Fl_Text_Display_Style_Table_Entry_Typer;
extern DaoTypeBase *dao_Fl_Text_Display_Unfinished_Style_Cb_Typer;
extern DaoTypeBase *dao_Fl_Text_Display_Unfinished_Style_Cb_x_Typer;
extern DaoTypeBase *dao_Fl_Text_Editor_Typer;
extern DaoTypeBase *dao_Fl_Text_Editor_Key_Binding_Typer;
extern DaoTypeBase *dao_Fl_Text_Editor_Key_Func_Typer;
extern DaoTypeBase *dao_Fl_Text_Editor_Key_Func_x_Typer;
extern DaoTypeBase *dao_Fl_Text_Selection_Typer;
extern DaoTypeBase *dao_Fl_Tile_Typer;
extern DaoTypeBase *dao_Fl_Tiled_Image_Typer;
extern DaoTypeBase *dao_Fl_Timer_Typer;
extern DaoTypeBase *dao_Fl_Toggle_Button_Typer;
extern DaoTypeBase *dao_Fl_Tooltip_Typer;
extern DaoTypeBase *dao_Fl_Tree_Typer;
extern DaoTypeBase *dao_Fl_Tree_Connector_Typer;
extern DaoTypeBase *dao_Fl_Tree_Item_Typer;
extern DaoTypeBase *dao_Fl_Tree_Item_Array_Typer;
extern DaoTypeBase *dao_Fl_Tree_Prefs_Typer;
extern DaoTypeBase *dao_Fl_Tree_Select_Typer;
extern DaoTypeBase *dao_Fl_Tree_Sort_Typer;
extern DaoTypeBase *dao_Fl_Value_Input_Typer;
extern DaoTypeBase *dao_Fl_Value_Output_Typer;
extern DaoTypeBase *dao_Fl_Widget_Tracker_Typer;
extern DaoTypeBase *dao_Fl_Wizard_Typer;
extern DaoTypeBase *dao_Fl_XBM_Image_Typer;
extern DaoTypeBase *dao_Fl_XPM_Image_Typer;
extern DaoTypeBase *dao_Flcc_HueBox_Typer;
extern DaoTypeBase *dao_Flcc_ValueBox_Typer;
extern DaoTypeBase *dao_Flcc_Value_Input_Typer;
extern DaoTypeBase *dao_GLdouble_Typer;
extern DaoTypeBase *dao_GLenum_Typer;
extern DaoTypeBase *dao_GLfloat_Typer;
extern DaoTypeBase *dao_GLint_Typer;
extern DaoTypeBase *dao_Matrix_Typer;
extern DaoTypeBase *dao_ResizeFlag_Typer;
extern DaoTypeBase *dao_Root_Typer;
extern DaoTypeBase *dao_TableContext_Typer;
extern DaoTypeBase *dao_TableRowSelectMode_Typer;
extern DaoTypeBase *dao_Fl_CString_Typer;
extern DaoTypeBase *dao_Fl_String_Typer;
extern DaoTypeBase *dao_GLContext_Typer;
void Dao_Fl_Callback( Fl_Widget* w, void *_ud );
#ifdef __cplusplus
}
#endif


FL_CHART_ENTRY* DAO_DLL_FLTK Dao_FL_CHART_ENTRY_New();

class DAO_DLL_FLTK DaoCxxVirt_Fl_Widget 
{
	public:
	DaoCxxVirt_Fl_Widget(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Widget *self, DaoCData *d );
	Fl_Widget *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	void draw( int &_cs  );
	int handle( int &_cs, int event );
	void hide( int &_cs  );
	void resize( int &_cs, int x, int y, int w, int h );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Widget : public Fl_Widget, public DaoCxxVirt_Fl_Widget
{ 
	public:
   DaoCxx_Fl_Widget( int x, int y, int w, int h, const char* label=0L ) : Fl_Widget( x, y, w, h, label ){}
	~DaoCxx_Fl_Widget();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	void draw(  );
	int handle( int event );
	void hide(  );
	void resize( int x, int y, int w, int h );
	void show(  );
	void DaoWrap_clear_flag( unsigned int c ){ Fl_Widget::clear_flag( c ); }
	void DaoWrap_draw_box(  )const{ Fl_Widget::draw_box(  ); }
	void DaoWrap_draw_box( Fl_Boxtype t, Fl_Color c )const{ Fl_Widget::draw_box( t, c ); }
	void DaoWrap_draw_box( Fl_Boxtype t, int x, int y, int w, int h, Fl_Color c )const{ Fl_Widget::draw_box( t, x, y, w, h, c ); }
	void DaoWrap_draw_focus(  ){ Fl_Widget::draw_focus(  ); }
	void DaoWrap_draw_focus( Fl_Boxtype t, int x, int y, int w, int h )const{ Fl_Widget::draw_focus( t, x, y, w, h ); }
	void DaoWrap_draw_label(  )const{ Fl_Widget::draw_label(  ); }
	void DaoWrap_draw_label( int _cp0, int _cp1, int _cp2, int _cp3 )const{ Fl_Widget::draw_label( _cp0, _cp1, _cp2, _cp3 ); }
	unsigned int DaoWrap_flags(  )const{ return Fl_Widget::flags(  ); }
	void DaoWrap_h( int v ){ Fl_Widget::h( v ); }
	void DaoWrap_set_flag( unsigned int c ){ Fl_Widget::set_flag( c ); }
	void DaoWrap_w( int v ){ Fl_Widget::w( v ); }
	void DaoWrap_x( int v ){ Fl_Widget::x( v ); }
	void DaoWrap_y( int v ){ Fl_Widget::y( v ); }
};
DaoCxx_Fl_Widget* DAO_DLL_FLTK DaoCxx_Fl_Widget_New( int x, int y, int w, int h, const char* label );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Group  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Fl_Group(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Group *self, DaoCData *d );
	Fl_Group *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	void hide( int &_cs  );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Group : public Fl_Group, public DaoCxxVirt_Fl_Group
{ 
	public:
   DaoCxx_Fl_Group( int _cp0, int _cp1, int _cp2, int _cp3, const char* _cp4 = 0 ) : Fl_Group( _cp0, _cp1, _cp2, _cp3, _cp4 ){}
	~DaoCxx_Fl_Group();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	void hide(  );
	void show(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Group::draw(  ); }
	void DaoWrap_draw_child( Fl_Widget &widget )const{ Fl_Group::draw_child( widget ); }
	void DaoWrap_draw_children(  ){ Fl_Group::draw_children(  ); }
	void DaoWrap_draw_outside_label( const Fl_Widget &widget )const{ Fl_Group::draw_outside_label( widget ); }
	int handle( int _cp0 );
	void resize( int _cp0, int _cp1, int _cp2, int _cp3 );
	int* DaoWrap_sizes(  ){ return Fl_Group::sizes(  ); }
	void DaoWrap_update_child( Fl_Widget &widget )const{ Fl_Group::update_child( widget ); }
};
DaoCxx_Fl_Group* DAO_DLL_FLTK DaoCxx_Fl_Group_New( int _cp0, int _cp1, int _cp2, int _cp3, const char* _cp4 );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Window  : public DaoCxxVirt_Fl_Group
{
	public:
	DaoCxxVirt_Fl_Window(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Window *self, DaoCData *d );
	Fl_Window *self;
	DaoCData *cdata;
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void draw( int &_cs  );
	void flush( int &_cs  );
	int handle( int &_cs, int _cp0 );
	void hide( int &_cs  );
	void resize( int &_cs, int _cp0, int _cp1, int _cp2, int _cp3 );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Window : public Fl_Window, public DaoCxxVirt_Fl_Window
{ 
	public:
   DaoCxx_Fl_Window( int w, int h, const char* title= 0 ) : Fl_Window( w, h, title ){}
   DaoCxx_Fl_Window( int x, int y, int w, int h, const char* title = 0 ) : Fl_Window( x, y, w, h, title ){}
	~DaoCxx_Fl_Window();
	void DaoInitWrapper();
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void draw(  );
	void flush(  );
	int handle( int _cp0 );
	void hide(  );
	void resize( int _cp0, int _cp1, int _cp2, int _cp3 );
	void show(  );
	void DaoWrap_draw(  ){ Fl_Window::draw(  ); }
	void DaoWrap_flush(  ){ Fl_Window::flush(  ); }
	int DaoWrap_force_position(  )const{ return Fl_Window::force_position(  ); }
	void DaoWrap_force_position( int force ){ Fl_Window::force_position( force ); }
};
DaoCxx_Fl_Window* DAO_DLL_FLTK DaoCxx_Fl_Window_New( int w, int h, const char* title );
DaoCxx_Fl_Window* DAO_DLL_FLTK DaoCxx_Fl_Window_New( int x, int y, int w, int h, const char* title );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Device 
{
	public:
	DaoCxxVirt_Fl_Device(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Device *self, DaoCData *d );
	Fl_Device *self;
	DaoCData *cdata;
	void arc( int &_cs, double x, double y, double r, double start, double a );
	void arc( int &_cs, int x, int y, int w, int h, double a1, double a2 );
	void begin_complex_polygon( int &_cs  );
	void begin_line( int &_cs  );
	void begin_loop( int &_cs  );
	void begin_points( int &_cs  );
	void begin_polygon( int &_cs  );
	void circle( int &_cs, double x, double y, double r );
	int clip_box( int &_cs, int x, int y, int w, int h, int& X, int& Y, int& W, int& H );
	void color( int &_cs, Fl_Color c );
	void color( int &_cs, uchar r, uchar g, uchar b );
	void curve( int &_cs, double x, double y, double x1, double y1, double x2, double y2, double x3, double y3 );
	void draw( int &_cs, Fl_Bitmap* bmp, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( int &_cs, Fl_Pixmap* pxm, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( int &_cs, Fl_RGB_Image* rgb, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( int &_cs, const char* str, int n, int x, int y );
	void draw( int &_cs, int angle, const char* str, int n, int x, int y );
	void draw_image( int &_cs, const uchar* _cp0, int _cp1, int _cp2, int _cp3, int _cp4, int delta, int ldelta );
	void draw_image_mono( int &_cs, const uchar* _cp0, int _cp1, int _cp2, int _cp3, int _cp4, int delta, int ld );
	void end_complex_polygon( int &_cs  );
	void end_line( int &_cs  );
	void end_loop( int &_cs  );
	void end_points( int &_cs  );
	void end_polygon( int &_cs  );
	void font( int &_cs, Fl_Font face, Fl_Fontsize size );
	void gap( int &_cs  );
	void line( int &_cs, int x, int y, int x1, int y1 );
	void line( int &_cs, int x, int y, int x1, int y1, int x2, int y2 );
	void line_style( int &_cs, int style, int width, char* dashes );
	void loop( int &_cs, int x0, int y0, int x1, int y1, int x2, int y2 );
	void loop( int &_cs, int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 );
	int not_clipped( int &_cs, int x, int y, int w, int h );
	void pie( int &_cs, int x, int y, int w, int h, double a1, double a2 );
	void point( int &_cs, int x, int y );
	void polygon( int &_cs, int x0, int y0, int x1, int y1, int x2, int y2 );
	void polygon( int &_cs, int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 );
	void pop_clip( int &_cs  );
	void push_clip( int &_cs, int x, int y, int w, int h );
	void push_no_clip( int &_cs  );
	void rect( int &_cs, int x, int y, int w, int h );
	void rectf( int &_cs, int x, int y, int w, int h );
	Fl_Device* set_current( int &_cs  );
	void transformed_vertex( int &_cs, double x, double y );
	void vertex( int &_cs, double x, double y );
	void xyline( int &_cs, int x, int y, int x1 );
	void xyline( int &_cs, int x, int y, int x1, int y2 );
	void xyline( int &_cs, int x, int y, int x1, int y2, int x3 );
	void yxline( int &_cs, int x, int y, int y1 );
	void yxline( int &_cs, int x, int y, int y1, int x2 );
	void yxline( int &_cs, int x, int y, int y1, int x2, int y3 );

};
class DAO_DLL_FLTK DaoCxx_Fl_Device : public Fl_Device, public DaoCxxVirt_Fl_Device
{ 
	public:
	~DaoCxx_Fl_Device();
	void DaoInitWrapper();
	void arc( double x, double y, double r, double start, double a );
	void arc( int x, int y, int w, int h, double a1, double a2 );
	void begin_complex_polygon(  );
	void begin_line(  );
	void begin_loop(  );
	void begin_points(  );
	void begin_polygon(  );
	void circle( double x, double y, double r );
	int clip_box( int x, int y, int w, int h, int& X, int& Y, int& W, int& H );
	void color( Fl_Color c );
	void color( uchar r, uchar g, uchar b );
	void curve( double x, double y, double x1, double y1, double x2, double y2, double x3, double y3 );
	void draw( Fl_Bitmap* bmp, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( Fl_Pixmap* pxm, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( Fl_RGB_Image* rgb, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( const char* str, int n, int x, int y );
	void draw( int angle, const char* str, int n, int x, int y );
	void draw_image( const uchar* _cp0, int _cp1, int _cp2, int _cp3, int _cp4, int delta=3, int ldelta=0 );
	void draw_image_mono( const uchar* _cp0, int _cp1, int _cp2, int _cp3, int _cp4, int delta=1, int ld=0 );
	void end_complex_polygon(  );
	void end_line(  );
	void end_loop(  );
	void end_points(  );
	void end_polygon(  );
	void font( Fl_Font face, Fl_Fontsize size );
	void gap(  );
	void line( int x, int y, int x1, int y1 );
	void line( int x, int y, int x1, int y1, int x2, int y2 );
	void line_style( int style, int width=0, char* dashes=0 );
	void loop( int x0, int y0, int x1, int y1, int x2, int y2 );
	void loop( int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 );
	int not_clipped( int x, int y, int w, int h );
	void pie( int x, int y, int w, int h, double a1, double a2 );
	void point( int x, int y );
	void polygon( int x0, int y0, int x1, int y1, int x2, int y2 );
	void polygon( int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 );
	void pop_clip(  );
	void push_clip( int x, int y, int w, int h );
	void push_no_clip(  );
	void rect( int x, int y, int w, int h );
	void rectf( int x, int y, int w, int h );
	Fl_Device* set_current(  );
	void transformed_vertex( double x, double y );
	void vertex( double x, double y );
	void xyline( int x, int y, int x1 );
	void xyline( int x, int y, int x1, int y2 );
	void xyline( int x, int y, int x1, int y2, int x3 );
	void yxline( int x, int y, int y1 );
	void yxline( int x, int y, int y1, int x2 );
	void yxline( int x, int y, int y1, int x2, int y3 );
	void DaoWrap_arc( double x, double y, double r, double start, double a ){ Fl_Device::arc( x, y, r, start, a ); }
	void DaoWrap_arc( int x, int y, int w, int h, double a1, double a2 ){ Fl_Device::arc( x, y, w, h, a1, a2 ); }
	void DaoWrap_begin_complex_polygon(  ){ Fl_Device::begin_complex_polygon(  ); }
	void DaoWrap_begin_line(  ){ Fl_Device::begin_line(  ); }
	void DaoWrap_begin_loop(  ){ Fl_Device::begin_loop(  ); }
	void DaoWrap_begin_points(  ){ Fl_Device::begin_points(  ); }
	void DaoWrap_begin_polygon(  ){ Fl_Device::begin_polygon(  ); }
	void DaoWrap_circle( double x, double y, double r ){ Fl_Device::circle( x, y, r ); }
	int DaoWrap_clip_box( int x, int y, int w, int h, int& X, int& Y, int& W, int& H ){ return Fl_Device::clip_box( x, y, w, h, X, Y, W, H ); }
	void DaoWrap_color( Fl_Color c ){ Fl_Device::color( c ); }
	void DaoWrap_color( uchar r, uchar g, uchar b ){ Fl_Device::color( r, g, b ); }
	void DaoWrap_curve( double x, double y, double x1, double y1, double x2, double y2, double x3, double y3 ){ Fl_Device::curve( x, y, x1, y1, x2, y2, x3, y3 ); }
	void DaoWrap_draw( Fl_Bitmap* bmp, int XP, int YP, int WP, int HP, int cx, int cy ){ Fl_Device::draw( bmp, XP, YP, WP, HP, cx, cy ); }
	void DaoWrap_draw( Fl_Pixmap* pxm, int XP, int YP, int WP, int HP, int cx, int cy ){ Fl_Device::draw( pxm, XP, YP, WP, HP, cx, cy ); }
	void DaoWrap_draw( Fl_RGB_Image* rgb, int XP, int YP, int WP, int HP, int cx, int cy ){ Fl_Device::draw( rgb, XP, YP, WP, HP, cx, cy ); }
	void DaoWrap_draw( const char* str, int n, int x, int y ){ Fl_Device::draw( str, n, x, y ); }
	void DaoWrap_draw( int angle, const char* str, int n, int x, int y ){ Fl_Device::draw( angle, str, n, x, y ); }
	void DaoWrap_draw_image( const uchar* _cp0, int _cp1, int _cp2, int _cp3, int _cp4, int delta=3, int ldelta=0 ){ Fl_Device::draw_image( _cp0, _cp1, _cp2, _cp3, _cp4, delta, ldelta ); }
	void DaoWrap_draw_image_mono( const uchar* _cp0, int _cp1, int _cp2, int _cp3, int _cp4, int delta=1, int ld=0 ){ Fl_Device::draw_image_mono( _cp0, _cp1, _cp2, _cp3, _cp4, delta, ld ); }
	void DaoWrap_end_complex_polygon(  ){ Fl_Device::end_complex_polygon(  ); }
	void DaoWrap_end_line(  ){ Fl_Device::end_line(  ); }
	void DaoWrap_end_loop(  ){ Fl_Device::end_loop(  ); }
	void DaoWrap_end_points(  ){ Fl_Device::end_points(  ); }
	void DaoWrap_end_polygon(  ){ Fl_Device::end_polygon(  ); }
	void DaoWrap_font( Fl_Font face, Fl_Fontsize size ){ Fl_Device::font( face, size ); }
	void DaoWrap_gap(  ){ Fl_Device::gap(  ); }
	void DaoWrap_line( int x, int y, int x1, int y1 ){ Fl_Device::line( x, y, x1, y1 ); }
	void DaoWrap_line( int x, int y, int x1, int y1, int x2, int y2 ){ Fl_Device::line( x, y, x1, y1, x2, y2 ); }
	void DaoWrap_line_style( int style, int width=0, char* dashes=0 ){ Fl_Device::line_style( style, width, dashes ); }
	void DaoWrap_loop( int x0, int y0, int x1, int y1, int x2, int y2 ){ Fl_Device::loop( x0, y0, x1, y1, x2, y2 ); }
	void DaoWrap_loop( int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 ){ Fl_Device::loop( x0, y0, x1, y1, x2, y2, x3, y3 ); }
	int DaoWrap_not_clipped( int x, int y, int w, int h ){ return Fl_Device::not_clipped( x, y, w, h ); }
	void DaoWrap_pie( int x, int y, int w, int h, double a1, double a2 ){ Fl_Device::pie( x, y, w, h, a1, a2 ); }
	void DaoWrap_point( int x, int y ){ Fl_Device::point( x, y ); }
	void DaoWrap_polygon( int x0, int y0, int x1, int y1, int x2, int y2 ){ Fl_Device::polygon( x0, y0, x1, y1, x2, y2 ); }
	void DaoWrap_polygon( int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 ){ Fl_Device::polygon( x0, y0, x1, y1, x2, y2, x3, y3 ); }
	void DaoWrap_pop_clip(  ){ Fl_Device::pop_clip(  ); }
	void DaoWrap_push_clip( int x, int y, int w, int h ){ Fl_Device::push_clip( x, y, w, h ); }
	void DaoWrap_push_no_clip(  ){ Fl_Device::push_no_clip(  ); }
	void DaoWrap_rect( int x, int y, int w, int h ){ Fl_Device::rect( x, y, w, h ); }
	void DaoWrap_rectf( int x, int y, int w, int h ){ Fl_Device::rectf( x, y, w, h ); }
	void DaoWrap_transformed_vertex( double x, double y ){ Fl_Device::transformed_vertex( x, y ); }
	void DaoWrap_vertex( double x, double y ){ Fl_Device::vertex( x, y ); }
	void DaoWrap_xyline( int x, int y, int x1 ){ Fl_Device::xyline( x, y, x1 ); }
	void DaoWrap_xyline( int x, int y, int x1, int y2 ){ Fl_Device::xyline( x, y, x1, y2 ); }
	void DaoWrap_xyline( int x, int y, int x1, int y2, int x3 ){ Fl_Device::xyline( x, y, x1, y2, x3 ); }
	void DaoWrap_yxline( int x, int y, int y1 ){ Fl_Device::yxline( x, y, y1 ); }
	void DaoWrap_yxline( int x, int y, int y1, int x2 ){ Fl_Device::yxline( x, y, y1, x2 ); }
	void DaoWrap_yxline( int x, int y, int y1, int x2, int y3 ){ Fl_Device::yxline( x, y, y1, x2, y3 ); }
};
Fl_Device* Dao_Fl_Device_Copy( const Fl_Device &p );
DaoCxx_Fl_Device* DAO_DLL_FLTK DaoCxx_Fl_Device_New(  );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Abstract_Printer  : public DaoCxxVirt_Fl_Device
{
	public:
	DaoCxxVirt_Fl_Abstract_Printer(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Abstract_Printer *self, DaoCData *d );
	Fl_Abstract_Printer *self;
	DaoCData *cdata;
	void arc( int &_cs, double x, double y, double r, double start, double a );
	void arc( int &_cs, int x, int y, int w, int h, double a1, double a2 );
	void begin_complex_polygon( int &_cs  );
	void begin_line( int &_cs  );
	void begin_loop( int &_cs  );
	void begin_points( int &_cs  );
	void begin_polygon( int &_cs  );
	void circle( int &_cs, double x, double y, double r );
	int clip_box( int &_cs, int x, int y, int w, int h, int& X, int& Y, int& W, int& H );
	void color( int &_cs, Fl_Color c );
	void color( int &_cs, uchar r, uchar g, uchar b );
	void curve( int &_cs, double x, double y, double x1, double y1, double x2, double y2, double x3, double y3 );
	void draw( int &_cs, Fl_Bitmap* bmp, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( int &_cs, Fl_Pixmap* pxm, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( int &_cs, Fl_RGB_Image* rgb, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( int &_cs, const char* str, int n, int x, int y );
	void draw( int &_cs, int angle, const char* str, int n, int x, int y );
	void draw_image( int &_cs, const uchar* _cp0, int _cp1, int _cp2, int _cp3, int _cp4, int delta, int ldelta );
	void draw_image_mono( int &_cs, const uchar* _cp0, int _cp1, int _cp2, int _cp3, int _cp4, int delta, int ld );
	void end_complex_polygon( int &_cs  );
	void end_job( int &_cs  );
	void end_line( int &_cs  );
	void end_loop( int &_cs  );
	int end_page( int &_cs  );
	void end_points( int &_cs  );
	void end_polygon( int &_cs  );
	void font( int &_cs, Fl_Font face, Fl_Fontsize size );
	void gap( int &_cs  );
	void line( int &_cs, int x, int y, int x1, int y1 );
	void line( int &_cs, int x, int y, int x1, int y1, int x2, int y2 );
	void line_style( int &_cs, int style, int width, char* dashes );
	void loop( int &_cs, int x0, int y0, int x1, int y1, int x2, int y2 );
	void loop( int &_cs, int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 );
	void margins( int &_cs, int* left, int* top, int* right, int* bottom );
	int not_clipped( int &_cs, int x, int y, int w, int h );
	void origin( int &_cs, int x, int y );
	void pie( int &_cs, int x, int y, int w, int h, double a1, double a2 );
	void point( int &_cs, int x, int y );
	void polygon( int &_cs, int x0, int y0, int x1, int y1, int x2, int y2 );
	void polygon( int &_cs, int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 );
	void pop_clip( int &_cs  );
	int printable_rect( int &_cs, int* w, int* h );
	void push_clip( int &_cs, int x, int y, int w, int h );
	void push_no_clip( int &_cs  );
	void rect( int &_cs, int x, int y, int w, int h );
	void rectf( int &_cs, int x, int y, int w, int h );
	void rotate( int &_cs, float angle );
	void scale( int &_cs, float scale_x, float scale_y );
	int start_job( int &_cs, int pagecount, int* frompage, int* topage );
	int start_page( int &_cs  );
	void transformed_vertex( int &_cs, double x, double y );
	void translate( int &_cs, int x, int y );
	void untranslate( int &_cs  );
	void vertex( int &_cs, double x, double y );
	void xyline( int &_cs, int x, int y, int x1 );
	void xyline( int &_cs, int x, int y, int x1, int y2 );
	void xyline( int &_cs, int x, int y, int x1, int y2, int x3 );
	void yxline( int &_cs, int x, int y, int y1 );
	void yxline( int &_cs, int x, int y, int y1, int x2 );
	void yxline( int &_cs, int x, int y, int y1, int x2, int y3 );

};
class DAO_DLL_FLTK DaoCxx_Fl_Abstract_Printer : public Fl_Abstract_Printer, public DaoCxxVirt_Fl_Abstract_Printer
{ 
	public:
	~DaoCxx_Fl_Abstract_Printer();
	void DaoInitWrapper();
	void arc( double x, double y, double r, double start, double a );
	void arc( int x, int y, int w, int h, double a1, double a2 );
	void begin_complex_polygon(  );
	void begin_line(  );
	void begin_loop(  );
	void begin_points(  );
	void begin_polygon(  );
	void circle( double x, double y, double r );
	int clip_box( int x, int y, int w, int h, int& X, int& Y, int& W, int& H );
	void color( Fl_Color c );
	void color( uchar r, uchar g, uchar b );
	void curve( double x, double y, double x1, double y1, double x2, double y2, double x3, double y3 );
	void draw( Fl_Bitmap* bmp, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( Fl_Pixmap* pxm, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( Fl_RGB_Image* rgb, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( const char* str, int n, int x, int y );
	void draw( int angle, const char* str, int n, int x, int y );
	void draw_image( const uchar* _cp0, int _cp1, int _cp2, int _cp3, int _cp4, int delta=3, int ldelta=0 );
	void draw_image_mono( const uchar* _cp0, int _cp1, int _cp2, int _cp3, int _cp4, int delta=1, int ld=0 );
	void end_complex_polygon(  );
	void end_job(  );
	void end_line(  );
	void end_loop(  );
	int end_page(  );
	void end_points(  );
	void end_polygon(  );
	void font( Fl_Font face, Fl_Fontsize size );
	void gap(  );
	void line( int x, int y, int x1, int y1 );
	void line( int x, int y, int x1, int y1, int x2, int y2 );
	void line_style( int style, int width=0, char* dashes=0 );
	void loop( int x0, int y0, int x1, int y1, int x2, int y2 );
	void loop( int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 );
	void margins( int* left, int* top, int* right, int* bottom );
	int not_clipped( int x, int y, int w, int h );
	void origin( int x, int y );
	void pie( int x, int y, int w, int h, double a1, double a2 );
	void point( int x, int y );
	void polygon( int x0, int y0, int x1, int y1, int x2, int y2 );
	void polygon( int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 );
	void pop_clip(  );
	int printable_rect( int* w, int* h );
	void push_clip( int x, int y, int w, int h );
	void push_no_clip(  );
	void rect( int x, int y, int w, int h );
	void rectf( int x, int y, int w, int h );
	void rotate( float angle );
	void scale( float scale_x, float scale_y );
	int start_job( int pagecount, int* frompage = NULL, int* topage = NULL );
	int start_page(  );
	void transformed_vertex( double x, double y );
	void translate( int x, int y );
	void untranslate(  );
	void vertex( double x, double y );
	void xyline( int x, int y, int x1 );
	void xyline( int x, int y, int x1, int y2 );
	void xyline( int x, int y, int x1, int y2, int x3 );
	void yxline( int x, int y, int y1 );
	void yxline( int x, int y, int y1, int x2 );
	void yxline( int x, int y, int y1, int x2, int y3 );
	void DaoWrap_delete_image_list(  ){ Fl_Abstract_Printer::delete_image_list(  ); }
	Fl_Device* set_current(  );
};
Fl_Abstract_Printer* Dao_Fl_Abstract_Printer_Copy( const Fl_Abstract_Printer &p );
DaoCxx_Fl_Abstract_Printer* DAO_DLL_FLTK DaoCxx_Fl_Abstract_Printer_New(  );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Valuator  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Fl_Valuator(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Valuator *self, DaoCData *d );
	Fl_Valuator *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	void draw( int &_cs  );
	int format( int &_cs, char* _cp0 );
	int handle( int &_cs, int event );
	void hide( int &_cs  );
	void resize( int &_cs, int x, int y, int w, int h );
	void show( int &_cs  );
	void value_damage( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Valuator : public Fl_Valuator, public DaoCxxVirt_Fl_Valuator
{ 
	public:
   DaoCxx_Fl_Valuator( int X, int Y, int W, int H, const char* L ) : Fl_Valuator( X, Y, W, H, L ){}
	~DaoCxx_Fl_Valuator();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	void draw(  );
	int format( char* _cp0 );
	int handle( int event );
	void hide(  );
	void resize( int x, int y, int w, int h );
	void show(  );
	void value_damage(  );
	void DaoWrap_handle_drag( double newvalue ){ Fl_Valuator::handle_drag( newvalue ); }
	void DaoWrap_handle_push(  ){ Fl_Valuator::handle_push(  ); }
	void DaoWrap_handle_release(  ){ Fl_Valuator::handle_release(  ); }
	int DaoWrap_horizontal(  )const{ return Fl_Valuator::horizontal(  ); }
	double DaoWrap_previous_value(  )const{ return Fl_Valuator::previous_value(  ); }
	void DaoWrap_set_value( double v ){ Fl_Valuator::set_value( v ); }
	double DaoWrap_softclamp( double _cp0 ){ return Fl_Valuator::softclamp( _cp0 ); }
	void DaoWrap_value_damage(  ){ Fl_Valuator::value_damage(  ); }
};
DaoCxx_Fl_Valuator* DAO_DLL_FLTK DaoCxx_Fl_Valuator_New( int X, int Y, int W, int H, const char* L );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Adjuster  : public DaoCxxVirt_Fl_Valuator
{
	public:
	DaoCxxVirt_Fl_Adjuster(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Adjuster *self, DaoCData *d );
	Fl_Adjuster *self;
	DaoCData *cdata;
	int format( int &_cs, char* _cp0 );

};
class DAO_DLL_FLTK DaoCxx_Fl_Adjuster : public Fl_Adjuster, public DaoCxxVirt_Fl_Adjuster
{ 
	public:
   DaoCxx_Fl_Adjuster( int X, int Y, int W, int H, const char* l=0 ) : Fl_Adjuster( X, Y, W, H, l ){}
	~DaoCxx_Fl_Adjuster();
	void DaoInitWrapper();
	int format( char* _cp0 );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Adjuster::draw(  ); }
	int handle( int _cp0 );
	int DaoWrap_handle( int _cp0 ){ return Fl_Adjuster::handle( _cp0 ); }
	void value_damage(  );
	void DaoWrap_value_damage(  ){ Fl_Adjuster::value_damage(  ); }
};
DaoCxx_Fl_Adjuster* DAO_DLL_FLTK DaoCxx_Fl_Adjuster_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Image 
{
	public:
	DaoCxxVirt_Fl_Image(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Image *self, DaoCData *d );
	Fl_Image *self;
	DaoCData *cdata;
	void color_average( int &_cs, Fl_Color c, float i );
	Fl_Image* copy( int &_cs, int W, int H );
	void desaturate( int &_cs  );
	void draw( int &_cs, int X, int Y, int W, int H, int cx, int cy );
	void label( int &_cs, Fl_Menu_Item* m );
	void label( int &_cs, Fl_Widget* w );
	void uncache( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Image : public Fl_Image, public DaoCxxVirt_Fl_Image
{ 
	public:
   DaoCxx_Fl_Image( int W, int H, int D ) : Fl_Image( W, H, D ){}
	~DaoCxx_Fl_Image();
	void DaoInitWrapper();
	void color_average( Fl_Color c, float i );
	Fl_Image* copy( int W, int H );
	void desaturate(  );
	void draw( int X, int Y, int W, int H, int cx=0, int cy=0 );
	void label( Fl_Menu_Item* m );
	void label( Fl_Widget* w );
	void uncache(  );
	void DaoWrap_d( int D ){ Fl_Image::d( D ); }
	void DaoWrap_draw_empty( int X, int Y ){ Fl_Image::draw_empty( X, Y ); }
	void DaoWrap_h( int H ){ Fl_Image::h( H ); }
	void DaoWrap_labeltype( const Fl_Label* lo, int lx, int ly, int lw, int lh, Fl_Align la ){ Fl_Image::labeltype( lo, lx, ly, lw, lh, la ); }
	void DaoWrap_ld( int LD ){ Fl_Image::ld( LD ); }
	void DaoWrap_measure( const Fl_Label* lo, int& lw, int& lh ){ Fl_Image::measure( lo, lw, lh ); }
	void DaoWrap_w( int W ){ Fl_Image::w( W ); }
};
DaoCxx_Fl_Image* DAO_DLL_FLTK DaoCxx_Fl_Image_New( int W, int H, int D );

class DAO_DLL_FLTK DaoCxxVirt_Fl_RGB_Image  : public DaoCxxVirt_Fl_Image
{
	public:
	DaoCxxVirt_Fl_RGB_Image(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_RGB_Image *self, DaoCData *d );
	Fl_RGB_Image *self;
	DaoCData *cdata;
	void color_average( int &_cs, Fl_Color c, float i );
	Fl_Image* copy( int &_cs, int W, int H );
	void desaturate( int &_cs  );
	void draw( int &_cs, int X, int Y, int W, int H, int cx, int cy );
	void label( int &_cs, Fl_Menu_Item* m );
	void label( int &_cs, Fl_Widget* w );
	void uncache( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_RGB_Image : public Fl_RGB_Image, public DaoCxxVirt_Fl_RGB_Image
{ 
	public:
   DaoCxx_Fl_RGB_Image( const uchar* bits, int W, int H, int D=3, int LD=0 ) : Fl_RGB_Image( bits, W, H, D, LD ){}
	~DaoCxx_Fl_RGB_Image();
	void DaoInitWrapper();
	void color_average( Fl_Color c, float i );
	Fl_Image* copy( int W, int H );
	void desaturate(  );
	void draw( int X, int Y, int W, int H, int cx=0, int cy=0 );
	void label( Fl_Menu_Item* m );
	void label( Fl_Widget* w );
	void uncache(  );
};
DaoCxx_Fl_RGB_Image* DAO_DLL_FLTK DaoCxx_Fl_RGB_Image_New( const uchar* bits, int W, int H, int D, int LD );

class DAO_DLL_FLTK DaoCxxVirt_Fl_BMP_Image  : public DaoCxxVirt_Fl_RGB_Image
{
	public:
	DaoCxxVirt_Fl_BMP_Image(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_BMP_Image *self, DaoCData *d );
	Fl_BMP_Image *self;
	DaoCData *cdata;
	void color_average( int &_cs, Fl_Color c, float i );
	Fl_Image* copy( int &_cs, int W, int H );
	void desaturate( int &_cs  );
	void draw( int &_cs, int X, int Y, int W, int H, int cx, int cy );
	void label( int &_cs, Fl_Menu_Item* m );
	void label( int &_cs, Fl_Widget* w );
	void uncache( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_BMP_Image : public Fl_BMP_Image, public DaoCxxVirt_Fl_BMP_Image
{ 
	public:
   DaoCxx_Fl_BMP_Image( const char* filename ) : Fl_BMP_Image( filename ){}
	~DaoCxx_Fl_BMP_Image();
	void DaoInitWrapper();
	void color_average( Fl_Color c, float i );
	Fl_Image* copy( int W, int H );
	void desaturate(  );
	void draw( int X, int Y, int W, int H, int cx=0, int cy=0 );
	void label( Fl_Menu_Item* m );
	void label( Fl_Widget* w );
	void uncache(  );
};
DaoCxx_Fl_BMP_Image* DAO_DLL_FLTK DaoCxx_Fl_BMP_Image_New( const char* filename );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Bitmap  : public DaoCxxVirt_Fl_Image
{
	public:
	DaoCxxVirt_Fl_Bitmap(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Bitmap *self, DaoCData *d );
	Fl_Bitmap *self;
	DaoCData *cdata;
	void color_average( int &_cs, Fl_Color c, float i );
	Fl_Image* copy( int &_cs, int W, int H );
	void desaturate( int &_cs  );
	void draw( int &_cs, int X, int Y, int W, int H, int cx, int cy );
	void label( int &_cs, Fl_Menu_Item* m );
	void label( int &_cs, Fl_Widget* w );
	void uncache( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Bitmap : public Fl_Bitmap, public DaoCxxVirt_Fl_Bitmap
{ 
	public:
   DaoCxx_Fl_Bitmap( const char* bits, int W, int H ) : Fl_Bitmap( bits, W, H ){}
   DaoCxx_Fl_Bitmap( const uchar* bits, int W, int H ) : Fl_Bitmap( bits, W, H ){}
	~DaoCxx_Fl_Bitmap();
	void DaoInitWrapper();
	void color_average( Fl_Color c, float i );
	Fl_Image* copy( int W, int H );
	void desaturate(  );
	void draw( int X, int Y, int W, int H, int cx=0, int cy=0 );
	void label( Fl_Menu_Item* m );
	void label( Fl_Widget* w );
	void uncache(  );
};
DaoCxx_Fl_Bitmap* DAO_DLL_FLTK DaoCxx_Fl_Bitmap_New( const char* bits, int W, int H );
DaoCxx_Fl_Bitmap* DAO_DLL_FLTK DaoCxx_Fl_Bitmap_New( const uchar* bits, int W, int H );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Box  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Fl_Box(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Box *self, DaoCData *d );
	Fl_Box *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	int handle( int &_cs, int _cp0 );
	void hide( int &_cs  );
	void resize( int &_cs, int x, int y, int w, int h );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Box : public Fl_Box, public DaoCxxVirt_Fl_Box
{ 
	public:
   DaoCxx_Fl_Box( Fl_Boxtype b, int X, int Y, int W, int H, const char* l ) : Fl_Box( b, X, Y, W, H, l ){}
   DaoCxx_Fl_Box( int X, int Y, int W, int H, const char* l=0 ) : Fl_Box( X, Y, W, H, l ){}
	~DaoCxx_Fl_Box();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	int handle( int _cp0 );
	void hide(  );
	void resize( int x, int y, int w, int h );
	void show(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Box::draw(  ); }
};
DaoCxx_Fl_Box* DAO_DLL_FLTK DaoCxx_Fl_Box_New( Fl_Boxtype b, int X, int Y, int W, int H, const char* l );
DaoCxx_Fl_Box* DAO_DLL_FLTK DaoCxx_Fl_Box_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Browser_  : public DaoCxxVirt_Fl_Group
{
	public:
	DaoCxxVirt_Fl_Browser_(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Browser_ *self, DaoCData *d );
	Fl_Browser_ *self;
	DaoCData *cdata;
	Fl_Group* as_group( int &_cs  );
	int full_height( int &_cs  )const;
	int full_width( int &_cs  )const;
	int incr_height( int &_cs  )const;
	void* item_at( int &_cs, int index )const;
	void item_draw( int &_cs, void* item, int X, int Y, int W, int H )const;
	void* item_first( int &_cs  )const;
	int item_height( int &_cs, void* item )const;
	void* item_last( int &_cs  )const;
	void* item_next( int &_cs, void* item )const;
	void* item_prev( int &_cs, void* item )const;
	int item_quick_height( int &_cs, void* item )const;
	void item_select( int &_cs, void* item, int val );
	int item_selected( int &_cs, void* item )const;
	void item_swap( int &_cs, void* a, void* b );
	const char* item_text( int &_cs, void* item )const;
	int item_width( int &_cs, void* item )const;

};
class DAO_DLL_FLTK DaoCxx_Fl_Browser_ : public Fl_Browser_, public DaoCxxVirt_Fl_Browser_
{ 
	public:
   DaoCxx_Fl_Browser_( int X, int Y, int W, int H, const char* L=0 ) : Fl_Browser_( X, Y, W, H, L ){}
	~DaoCxx_Fl_Browser_();
	void DaoInitWrapper();
	Fl_Group* as_group(  );
	int full_height(  )const;
	int full_width(  )const;
	int incr_height(  )const;
	void* item_at( int index )const;
	void item_draw( void* item, int X, int Y, int W, int H )const;
	void* item_first(  )const;
	int item_height( void* item )const;
	void* item_last(  )const;
	void* item_next( void* item )const;
	void* item_prev( void* item )const;
	int item_quick_height( void* item )const;
	void item_select( void* item, int val=1 );
	int item_selected( void* item )const;
	void item_swap( void* a, void* b );
	const char* item_text( void* item )const;
	int item_width( void* item )const;
	void DaoWrap_bbox( int& X, int& Y, int& W, int& H )const{ Fl_Browser_::bbox( X, Y, W, H ); }
	void DaoWrap_deleting( void* item ){ Fl_Browser_::deleting( item ); }
	int DaoWrap_displayed( void* item )const{ return Fl_Browser_::displayed( item ); }
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Browser_::draw(  ); }
	void* DaoWrap_find_item( int ypos ){ Fl_Browser_::find_item( ypos ); }
	int DaoWrap_full_height(  )const{ return Fl_Browser_::full_height(  ); }
	int DaoWrap_full_width(  )const{ return Fl_Browser_::full_width(  ); }
	int handle( int event );
	int DaoWrap_incr_height(  )const{ return Fl_Browser_::incr_height(  ); }
	void DaoWrap_inserting( void* a, void* b ){ Fl_Browser_::inserting( a, b ); }
	void* DaoWrap_item_at( int index )const{ Fl_Browser_::item_at( index ); }
	void DaoWrap_item_draw( void* item, int X, int Y, int W, int H )const{ Fl_Browser_::item_draw( item, X, Y, W, H ); }
	void* DaoWrap_item_first(  )const{ Fl_Browser_::item_first(  ); }
	int DaoWrap_item_height( void* item )const{ return Fl_Browser_::item_height( item ); }
	void* DaoWrap_item_last(  )const{ Fl_Browser_::item_last(  ); }
	void* DaoWrap_item_next( void* item )const{ Fl_Browser_::item_next( item ); }
	void* DaoWrap_item_prev( void* item )const{ Fl_Browser_::item_prev( item ); }
	int DaoWrap_item_quick_height( void* item )const{ return Fl_Browser_::item_quick_height( item ); }
	void DaoWrap_item_select( void* item, int val=1 ){ Fl_Browser_::item_select( item, val ); }
	int DaoWrap_item_selected( void* item )const{ return Fl_Browser_::item_selected( item ); }
	void DaoWrap_item_swap( void* a, void* b ){ Fl_Browser_::item_swap( a, b ); }
	const char* DaoWrap_item_text( void* item )const{ return Fl_Browser_::item_text( item ); }
	int DaoWrap_item_width( void* item )const{ return Fl_Browser_::item_width( item ); }
	int DaoWrap_leftedge(  )const{ return Fl_Browser_::leftedge(  ); }
	void DaoWrap_new_list(  ){ Fl_Browser_::new_list(  ); }
	void DaoWrap_redraw_line( void* item ){ Fl_Browser_::redraw_line( item ); }
	void DaoWrap_redraw_lines(  ){ Fl_Browser_::redraw_lines(  ); }
	void DaoWrap_replacing( void* a, void* b ){ Fl_Browser_::replacing( a, b ); }
	void resize( int X, int Y, int W, int H );
	void* DaoWrap_selection(  )const{ Fl_Browser_::selection(  ); }
	void DaoWrap_swapping( void* a, void* b ){ Fl_Browser_::swapping( a, b ); }
	void* DaoWrap_top(  )const{ Fl_Browser_::top(  ); }
};
DaoCxx_Fl_Browser_* DAO_DLL_FLTK DaoCxx_Fl_Browser__New( int X, int Y, int W, int H, const char* L );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Browser  : public DaoCxxVirt_Fl_Browser_
{
	public:
	DaoCxxVirt_Fl_Browser(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Browser *self, DaoCData *d );
	Fl_Browser *self;
	DaoCData *cdata;
	int full_width( int &_cs  )const;
	int item_quick_height( int &_cs, void* item )const;

};
class DAO_DLL_FLTK DaoCxx_Fl_Browser : public Fl_Browser, public DaoCxxVirt_Fl_Browser
{ 
	public:
   DaoCxx_Fl_Browser( int X, int Y, int W, int H, const char* L = 0 ) : Fl_Browser( X, Y, W, H, L ){}
	~DaoCxx_Fl_Browser();
	void DaoInitWrapper();
	int full_width(  )const;
	int item_quick_height( void* item )const;
	FL_BLINE* DaoWrap__remove( int line ){ return Fl_Browser::_remove( line ); }
	FL_BLINE* DaoWrap_find_line( int line )const{ return Fl_Browser::find_line( line ); }
	int full_height(  )const;
	int DaoWrap_full_height(  )const{ return Fl_Browser::full_height(  ); }
	void hide(  );
	int incr_height(  )const;
	int DaoWrap_incr_height(  )const{ return Fl_Browser::incr_height(  ); }
	void DaoWrap_insert( int line, FL_BLINE* item ){ Fl_Browser::insert( line, item ); }
	void* item_at( int line )const;
	void* DaoWrap_item_at( int line )const{ Fl_Browser::item_at( line ); }
	void item_draw( void* item, int X, int Y, int W, int H )const;
	void DaoWrap_item_draw( void* item, int X, int Y, int W, int H )const{ Fl_Browser::item_draw( item, X, Y, W, H ); }
	void* item_first(  )const;
	void* DaoWrap_item_first(  )const{ Fl_Browser::item_first(  ); }
	int item_height( void* item )const;
	int DaoWrap_item_height( void* item )const{ return Fl_Browser::item_height( item ); }
	void* item_last(  )const;
	void* DaoWrap_item_last(  )const{ Fl_Browser::item_last(  ); }
	void* item_next( void* item )const;
	void* DaoWrap_item_next( void* item )const{ Fl_Browser::item_next( item ); }
	void* item_prev( void* item )const;
	void* DaoWrap_item_prev( void* item )const{ Fl_Browser::item_prev( item ); }
	void item_select( void* item, int val );
	void DaoWrap_item_select( void* item, int val ){ Fl_Browser::item_select( item, val ); }
	int item_selected( void* item )const;
	int DaoWrap_item_selected( void* item )const{ return Fl_Browser::item_selected( item ); }
	void item_swap( void* a, void* b );
	void DaoWrap_item_swap( void* a, void* b ){ Fl_Browser::item_swap( a, b ); }
	const char* item_text( void* item )const;
	const char* DaoWrap_item_text( void* item )const{ return Fl_Browser::item_text( item ); }
	int item_width( void* item )const;
	int DaoWrap_item_width( void* item )const{ return Fl_Browser::item_width( item ); }
	int DaoWrap_lineno( void* item )const{ return Fl_Browser::lineno( item ); }
	void show(  );
	void DaoWrap_swap( FL_BLINE* a, FL_BLINE* b ){ Fl_Browser::swap( a, b ); }
};
DaoCxx_Fl_Browser* DAO_DLL_FLTK DaoCxx_Fl_Browser_New( int X, int Y, int W, int H, const char* L );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Button  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Fl_Button(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Button *self, DaoCData *d );
	Fl_Button *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	void draw( int &_cs  );
	int handle( int &_cs, int _cp0 );
	void hide( int &_cs  );
	void resize( int &_cs, int x, int y, int w, int h );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Button : public Fl_Button, public DaoCxxVirt_Fl_Button
{ 
	public:
   DaoCxx_Fl_Button( int X, int Y, int W, int H, const char* L = 0 ) : Fl_Button( X, Y, W, H, L ){}
	~DaoCxx_Fl_Button();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	void draw(  );
	int handle( int _cp0 );
	void hide(  );
	void resize( int x, int y, int w, int h );
	void show(  );
	void DaoWrap_draw(  ){ Fl_Button::draw(  ); }
};
DaoCxx_Fl_Button* DAO_DLL_FLTK DaoCxx_Fl_Button_New( int X, int Y, int W, int H, const char* L );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Chart  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Fl_Chart(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Chart *self, DaoCData *d );
	Fl_Chart *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	int handle( int &_cs, int event );
	void hide( int &_cs  );
	void resize( int &_cs, int x, int y, int w, int h );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Chart : public Fl_Chart, public DaoCxxVirt_Fl_Chart
{ 
	public:
   DaoCxx_Fl_Chart( int X, int Y, int W, int H, const char* L = 0 ) : Fl_Chart( X, Y, W, H, L ){}
	~DaoCxx_Fl_Chart();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	int handle( int event );
	void hide(  );
	void resize( int x, int y, int w, int h );
	void show(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Chart::draw(  ); }
};
DaoCxx_Fl_Chart* DAO_DLL_FLTK DaoCxx_Fl_Chart_New( int X, int Y, int W, int H, const char* L );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Check_Browser  : public DaoCxxVirt_Fl_Browser_
{
	public:
	DaoCxxVirt_Fl_Check_Browser(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Check_Browser *self, DaoCData *d );
	Fl_Check_Browser *self;
	DaoCData *cdata;
	int full_height( int &_cs  )const;
	int full_width( int &_cs  )const;
	int incr_height( int &_cs  )const;
	void* item_at( int &_cs, int index )const;
	void* item_last( int &_cs  )const;
	int item_quick_height( int &_cs, void* item )const;
	void item_swap( int &_cs, void* a, void* b );
	const char* item_text( int &_cs, void* item )const;

};
class DAO_DLL_FLTK DaoCxx_Fl_Check_Browser : public Fl_Check_Browser, public DaoCxxVirt_Fl_Check_Browser
{ 
	public:
   DaoCxx_Fl_Check_Browser( int x, int y, int w, int h, const char* l = 0 ) : Fl_Check_Browser( x, y, w, h, l ){}
	~DaoCxx_Fl_Check_Browser();
	void DaoInitWrapper();
	int full_height(  )const;
	int full_width(  )const;
	int incr_height(  )const;
	void* item_at( int index )const;
	void* item_last(  )const;
	int item_quick_height( void* item )const;
	void item_swap( void* a, void* b );
	const char* item_text( void* item )const;
	int handle( int _cp0 );
	int DaoWrap_handle( int _cp0 ){ return Fl_Check_Browser::handle( _cp0 ); }
};
DaoCxx_Fl_Check_Browser* DAO_DLL_FLTK DaoCxx_Fl_Check_Browser_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Light_Button  : public DaoCxxVirt_Fl_Button
{
	public:
	DaoCxxVirt_Fl_Light_Button(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Light_Button *self, DaoCData *d );
	Fl_Light_Button *self;
	DaoCData *cdata;
	void draw( int &_cs  );
	int handle( int &_cs, int _cp0 );

};
class DAO_DLL_FLTK DaoCxx_Fl_Light_Button : public Fl_Light_Button, public DaoCxxVirt_Fl_Light_Button
{ 
	public:
   DaoCxx_Fl_Light_Button( int x, int y, int w, int h, const char* l = 0 ) : Fl_Light_Button( x, y, w, h, l ){}
	~DaoCxx_Fl_Light_Button();
	void DaoInitWrapper();
	void draw(  );
	int handle( int _cp0 );
	void DaoWrap_draw(  ){ Fl_Light_Button::draw(  ); }
};
DaoCxx_Fl_Light_Button* DAO_DLL_FLTK DaoCxx_Fl_Light_Button_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Check_Button  : public DaoCxxVirt_Fl_Light_Button
{
	public:
	DaoCxxVirt_Fl_Check_Button(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Check_Button *self, DaoCData *d );
	Fl_Check_Button *self;
	DaoCData *cdata;
	void draw( int &_cs  );
	int handle( int &_cs, int _cp0 );

};
class DAO_DLL_FLTK DaoCxx_Fl_Check_Button : public Fl_Check_Button, public DaoCxxVirt_Fl_Check_Button
{ 
	public:
   DaoCxx_Fl_Check_Button( int X, int Y, int W, int H, const char* L = 0 ) : Fl_Check_Button( X, Y, W, H, L ){}
	~DaoCxx_Fl_Check_Button();
	void DaoInitWrapper();
	void draw(  );
	int handle( int _cp0 );
};
DaoCxx_Fl_Check_Button* DAO_DLL_FLTK DaoCxx_Fl_Check_Button_New( int X, int Y, int W, int H, const char* L );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Menu_  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Fl_Menu_(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Menu_ *self, DaoCData *d );
	Fl_Menu_ *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	void draw( int &_cs  );
	int handle( int &_cs, int event );
	void hide( int &_cs  );
	void resize( int &_cs, int x, int y, int w, int h );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Menu_ : public Fl_Menu_, public DaoCxxVirt_Fl_Menu_
{ 
	public:
   DaoCxx_Fl_Menu_( int _cp0, int _cp1, int _cp2, int _cp3, const char* _cp4 =0 ) : Fl_Menu_( _cp0, _cp1, _cp2, _cp3, _cp4 ){}
	~DaoCxx_Fl_Menu_();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	void draw(  );
	int handle( int event );
	void hide(  );
	void resize( int x, int y, int w, int h );
	void show(  );
};
DaoCxx_Fl_Menu_* DAO_DLL_FLTK DaoCxx_Fl_Menu__New( int _cp0, int _cp1, int _cp2, int _cp3, const char* _cp4 );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Choice  : public DaoCxxVirt_Fl_Menu_
{
	public:
	DaoCxxVirt_Fl_Choice(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Choice *self, DaoCData *d );
	Fl_Choice *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Choice : public Fl_Choice, public DaoCxxVirt_Fl_Choice
{ 
	public:
   DaoCxx_Fl_Choice( int X, int Y, int W, int H, const char* L = 0 ) : Fl_Choice( X, Y, W, H, L ){}
	~DaoCxx_Fl_Choice();
	void DaoInitWrapper();
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Choice::draw(  ); }
	int handle( int _cp0 );
};
DaoCxx_Fl_Choice* DAO_DLL_FLTK DaoCxx_Fl_Choice_New( int X, int Y, int W, int H, const char* L );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Clock_Output  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Fl_Clock_Output(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Clock_Output *self, DaoCData *d );
	Fl_Clock_Output *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	int handle( int &_cs, int event );
	void hide( int &_cs  );
	void resize( int &_cs, int x, int y, int w, int h );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Clock_Output : public Fl_Clock_Output, public DaoCxxVirt_Fl_Clock_Output
{ 
	public:
   DaoCxx_Fl_Clock_Output( int X, int Y, int W, int H, const char* L = 0 ) : Fl_Clock_Output( X, Y, W, H, L ){}
	~DaoCxx_Fl_Clock_Output();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	int handle( int event );
	void hide(  );
	void resize( int x, int y, int w, int h );
	void show(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Clock_Output::draw(  ); }
	void DaoWrap_draw( int X, int Y, int W, int H ){ Fl_Clock_Output::draw( X, Y, W, H ); }
};
DaoCxx_Fl_Clock_Output* DAO_DLL_FLTK DaoCxx_Fl_Clock_Output_New( int X, int Y, int W, int H, const char* L );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Clock  : public DaoCxxVirt_Fl_Clock_Output
{
	public:
	DaoCxxVirt_Fl_Clock(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Clock *self, DaoCData *d );
	Fl_Clock *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Clock : public Fl_Clock, public DaoCxxVirt_Fl_Clock
{ 
	public:
   DaoCxx_Fl_Clock( int X, int Y, int W, int H, const char* L = 0 ) : Fl_Clock( X, Y, W, H, L ){}
   DaoCxx_Fl_Clock( uchar t, int X, int Y, int W, int H, const char* L ) : Fl_Clock( t, X, Y, W, H, L ){}
	~DaoCxx_Fl_Clock();
	void DaoInitWrapper();
	int handle( int _cp0 );
};
DaoCxx_Fl_Clock* DAO_DLL_FLTK DaoCxx_Fl_Clock_New( int X, int Y, int W, int H, const char* L );
DaoCxx_Fl_Clock* DAO_DLL_FLTK DaoCxx_Fl_Clock_New( uchar t, int X, int Y, int W, int H, const char* L );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Color_Chooser  : public DaoCxxVirt_Fl_Group
{
	public:
	DaoCxxVirt_Fl_Color_Chooser(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Color_Chooser *self, DaoCData *d );
	Fl_Color_Chooser *self;
	DaoCData *cdata;
	Fl_Group* as_group( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Color_Chooser : public Fl_Color_Chooser, public DaoCxxVirt_Fl_Color_Chooser
{ 
	public:
   DaoCxx_Fl_Color_Chooser( int X, int Y, int W, int H, const char* L = 0 ) : Fl_Color_Chooser( X, Y, W, H, L ){}
	~DaoCxx_Fl_Color_Chooser();
	void DaoInitWrapper();
	Fl_Group* as_group(  );
};
DaoCxx_Fl_Color_Chooser* DAO_DLL_FLTK DaoCxx_Fl_Color_Chooser_New( int X, int Y, int W, int H, const char* L );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Counter  : public DaoCxxVirt_Fl_Valuator
{
	public:
	DaoCxxVirt_Fl_Counter(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Counter *self, DaoCData *d );
	Fl_Counter *self;
	DaoCData *cdata;
	int format( int &_cs, char* _cp0 );
	void value_damage( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Counter : public Fl_Counter, public DaoCxxVirt_Fl_Counter
{ 
	public:
   DaoCxx_Fl_Counter( int X, int Y, int W, int H, const char* L = 0 ) : Fl_Counter( X, Y, W, H, L ){}
	~DaoCxx_Fl_Counter();
	void DaoInitWrapper();
	int format( char* _cp0 );
	void value_damage(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Counter::draw(  ); }
	int handle( int _cp0 );
};
DaoCxx_Fl_Counter* DAO_DLL_FLTK DaoCxx_Fl_Counter_New( int X, int Y, int W, int H, const char* L );


Fl_Plugin* DAO_DLL_FLTK Dao_Fl_Plugin_New( const char* klass, const char* name );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Device_Plugin 
{
	public:
	DaoCxxVirt_Fl_Device_Plugin(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Device_Plugin *self, DaoCData *d );
	Fl_Device_Plugin *self;
	DaoCData *cdata;
	const char* klass( int &_cs  );
	const char* name( int &_cs  );
	int print( int &_cs, Fl_Abstract_Printer* _cp0, Fl_Widget* _cp1, int x, int y );

};
class DAO_DLL_FLTK DaoCxx_Fl_Device_Plugin : public Fl_Device_Plugin, public DaoCxxVirt_Fl_Device_Plugin
{ 
	public:
   DaoCxx_Fl_Device_Plugin( const char* name ) : Fl_Device_Plugin( name ){}
	~DaoCxx_Fl_Device_Plugin();
	void DaoInitWrapper();
	const char* klass(  );
	const char* name(  );
	int print( Fl_Abstract_Printer* _cp0, Fl_Widget* _cp1, int x, int y );
};
DaoCxx_Fl_Device_Plugin* DAO_DLL_FLTK DaoCxx_Fl_Device_Plugin_New( const char* name );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Dial  : public DaoCxxVirt_Fl_Valuator
{
	public:
	DaoCxxVirt_Fl_Dial(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Dial *self, DaoCData *d );
	Fl_Dial *self;
	DaoCData *cdata;
	int format( int &_cs, char* _cp0 );
	void value_damage( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Dial : public Fl_Dial, public DaoCxxVirt_Fl_Dial
{ 
	public:
   DaoCxx_Fl_Dial( int x, int y, int w, int h, const char* l = 0 ) : Fl_Dial( x, y, w, h, l ){}
	~DaoCxx_Fl_Dial();
	void DaoInitWrapper();
	int format( char* _cp0 );
	void value_damage(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Dial::draw(  ); }
	void DaoWrap_draw( int X, int Y, int W, int H ){ Fl_Dial::draw( X, Y, W, H ); }
	int handle( int _cp0 );
	int DaoWrap_handle( int event, int X, int Y, int W, int H ){ return Fl_Dial::handle( event, X, Y, W, H ); }
};
DaoCxx_Fl_Dial* DAO_DLL_FLTK DaoCxx_Fl_Dial_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Display  : public DaoCxxVirt_Fl_Device
{
	public:
	DaoCxxVirt_Fl_Display(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Display *self, DaoCData *d );
	Fl_Display *self;
	DaoCData *cdata;
	void arc( int &_cs, double x, double y, double r, double start, double a );
	void arc( int &_cs, int x, int y, int w, int h, double a1, double a2 );
	void begin_complex_polygon( int &_cs  );
	void begin_line( int &_cs  );
	void begin_loop( int &_cs  );
	void begin_points( int &_cs  );
	void begin_polygon( int &_cs  );
	void circle( int &_cs, double x, double y, double r );
	int clip_box( int &_cs, int x, int y, int w, int h, int& X, int& Y, int& W, int& H );
	void color( int &_cs, Fl_Color c );
	void color( int &_cs, uchar r, uchar g, uchar b );
	void curve( int &_cs, double x, double y, double x1, double y1, double x2, double y2, double x3, double y3 );
	void draw( int &_cs, Fl_Bitmap* bmp, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( int &_cs, Fl_Pixmap* pxm, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( int &_cs, Fl_RGB_Image* rgb, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( int &_cs, const char* str, int n, int x, int y );
	void draw( int &_cs, int angle, const char* str, int n, int x, int y );
	void draw_image( int &_cs, const uchar* _cp0, int _cp1, int _cp2, int _cp3, int _cp4, int delta, int ldelta );
	void draw_image_mono( int &_cs, const uchar* _cp0, int _cp1, int _cp2, int _cp3, int _cp4, int delta, int ld );
	void end_complex_polygon( int &_cs  );
	void end_line( int &_cs  );
	void end_loop( int &_cs  );
	void end_points( int &_cs  );
	void end_polygon( int &_cs  );
	void font( int &_cs, Fl_Font face, Fl_Fontsize size );
	void gap( int &_cs  );
	void line( int &_cs, int x, int y, int x1, int y1 );
	void line( int &_cs, int x, int y, int x1, int y1, int x2, int y2 );
	void line_style( int &_cs, int style, int width, char* dashes );
	void loop( int &_cs, int x0, int y0, int x1, int y1, int x2, int y2 );
	void loop( int &_cs, int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 );
	int not_clipped( int &_cs, int x, int y, int w, int h );
	void pie( int &_cs, int x, int y, int w, int h, double a1, double a2 );
	void point( int &_cs, int x, int y );
	void polygon( int &_cs, int x0, int y0, int x1, int y1, int x2, int y2 );
	void polygon( int &_cs, int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 );
	void pop_clip( int &_cs  );
	void push_clip( int &_cs, int x, int y, int w, int h );
	void push_no_clip( int &_cs  );
	void rect( int &_cs, int x, int y, int w, int h );
	void rectf( int &_cs, int x, int y, int w, int h );
	Fl_Device* set_current( int &_cs  );
	void transformed_vertex( int &_cs, double x, double y );
	void vertex( int &_cs, double x, double y );
	void xyline( int &_cs, int x, int y, int x1 );
	void xyline( int &_cs, int x, int y, int x1, int y2 );
	void xyline( int &_cs, int x, int y, int x1, int y2, int x3 );
	void yxline( int &_cs, int x, int y, int y1 );
	void yxline( int &_cs, int x, int y, int y1, int x2 );
	void yxline( int &_cs, int x, int y, int y1, int x2, int y3 );

};
class DAO_DLL_FLTK DaoCxx_Fl_Display : public Fl_Display, public DaoCxxVirt_Fl_Display
{ 
	public:
	~DaoCxx_Fl_Display();
	void DaoInitWrapper();
	void arc( double x, double y, double r, double start, double a );
	void arc( int x, int y, int w, int h, double a1, double a2 );
	void begin_complex_polygon(  );
	void begin_line(  );
	void begin_loop(  );
	void begin_points(  );
	void begin_polygon(  );
	void circle( double x, double y, double r );
	int clip_box( int x, int y, int w, int h, int& X, int& Y, int& W, int& H );
	void color( Fl_Color c );
	void color( uchar r, uchar g, uchar b );
	void curve( double x, double y, double x1, double y1, double x2, double y2, double x3, double y3 );
	void draw( Fl_Bitmap* bmp, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( Fl_Pixmap* pxm, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( Fl_RGB_Image* rgb, int XP, int YP, int WP, int HP, int cx, int cy );
	void draw( const char* str, int n, int x, int y );
	void draw( int angle, const char* str, int n, int x, int y );
	void draw_image( const uchar* _cp0, int _cp1, int _cp2, int _cp3, int _cp4, int delta=3, int ldelta=0 );
	void draw_image_mono( const uchar* _cp0, int _cp1, int _cp2, int _cp3, int _cp4, int delta=1, int ld=0 );
	void end_complex_polygon(  );
	void end_line(  );
	void end_loop(  );
	void end_points(  );
	void end_polygon(  );
	void font( Fl_Font face, Fl_Fontsize size );
	void gap(  );
	void line( int x, int y, int x1, int y1 );
	void line( int x, int y, int x1, int y1, int x2, int y2 );
	void line_style( int style, int width=0, char* dashes=0 );
	void loop( int x0, int y0, int x1, int y1, int x2, int y2 );
	void loop( int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 );
	int not_clipped( int x, int y, int w, int h );
	void pie( int x, int y, int w, int h, double a1, double a2 );
	void point( int x, int y );
	void polygon( int x0, int y0, int x1, int y1, int x2, int y2 );
	void polygon( int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 );
	void pop_clip(  );
	void push_clip( int x, int y, int w, int h );
	void push_no_clip(  );
	void rect( int x, int y, int w, int h );
	void rectf( int x, int y, int w, int h );
	Fl_Device* set_current(  );
	void transformed_vertex( double x, double y );
	void vertex( double x, double y );
	void xyline( int x, int y, int x1 );
	void xyline( int x, int y, int x1, int y2 );
	void xyline( int x, int y, int x1, int y2, int x3 );
	void yxline( int x, int y, int y1 );
	void yxline( int x, int y, int y1, int x2 );
	void yxline( int x, int y, int y1, int x2, int y3 );
};
Fl_Display* Dao_Fl_Display_Copy( const Fl_Display &p );
DaoCxx_Fl_Display* DAO_DLL_FLTK DaoCxx_Fl_Display_New(  );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Double_Window  : public DaoCxxVirt_Fl_Window
{
	public:
	DaoCxxVirt_Fl_Double_Window(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Double_Window *self, DaoCData *d );
	Fl_Double_Window *self;
	DaoCData *cdata;
	Fl_Window* as_window( int &_cs  );
	void draw( int &_cs  );
	int handle( int &_cs, int _cp0 );

};
class DAO_DLL_FLTK DaoCxx_Fl_Double_Window : public Fl_Double_Window, public DaoCxxVirt_Fl_Double_Window
{ 
	public:
   DaoCxx_Fl_Double_Window( int W, int H, const char* l = 0 ) : Fl_Double_Window( W, H, l ){}
   DaoCxx_Fl_Double_Window( int X, int Y, int W, int H, const char* l = 0 ) : Fl_Double_Window( X, Y, W, H, l ){}
	~DaoCxx_Fl_Double_Window();
	void DaoInitWrapper();
	Fl_Window* as_window(  );
	void draw(  );
	int handle( int _cp0 );
	void flush(  );
	void DaoWrap_flush( int eraseoverlay ){ Fl_Double_Window::flush( eraseoverlay ); }
	void hide(  );
	void resize( int _cp0, int _cp1, int _cp2, int _cp3 );
	void show(  );
};
DaoCxx_Fl_Double_Window* DAO_DLL_FLTK DaoCxx_Fl_Double_Window_New( int W, int H, const char* l );
DaoCxx_Fl_Double_Window* DAO_DLL_FLTK DaoCxx_Fl_Double_Window_New( int X, int Y, int W, int H, const char* l );


Fl_End* DAO_DLL_FLTK Dao_Fl_End_New(  );

class DAO_DLL_FLTK DaoCxxVirt_Fl_File_Browser  : public DaoCxxVirt_Fl_Browser
{
	public:
	DaoCxxVirt_Fl_File_Browser(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_File_Browser *self, DaoCData *d );
	Fl_File_Browser *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_File_Browser : public Fl_File_Browser, public DaoCxxVirt_Fl_File_Browser
{ 
	public:
   DaoCxx_Fl_File_Browser( int _cp0, int _cp1, int _cp2, int _cp3, const char* _cp4 = 0 ) : Fl_File_Browser( _cp0, _cp1, _cp2, _cp3, _cp4 ){}
	~DaoCxx_Fl_File_Browser();
	void DaoInitWrapper();

};
DaoCxx_Fl_File_Browser* DAO_DLL_FLTK DaoCxx_Fl_File_Browser_New( int _cp0, int _cp1, int _cp2, int _cp3, const char* _cp4 );


Fl_File_Chooser* DAO_DLL_FLTK Dao_Fl_File_Chooser_New( const char* d, const char* p, int t, const char* title );


Fl_File_Icon* DAO_DLL_FLTK Dao_Fl_File_Icon_New( const char* p, int t, int nd, short* d );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Input_  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Fl_Input_(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Input_ *self, DaoCData *d );
	Fl_Input_ *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	void draw( int &_cs  );
	int handle( int &_cs, int event );
	void hide( int &_cs  );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Input_ : public Fl_Input_, public DaoCxxVirt_Fl_Input_
{ 
	public:
   DaoCxx_Fl_Input_( int _cp0, int _cp1, int _cp2, int _cp3, const char* _cp4 = 0 ) : Fl_Input_( _cp0, _cp1, _cp2, _cp3, _cp4 ){}
	~DaoCxx_Fl_Input_();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	void draw(  );
	int handle( int event );
	void hide(  );
	void show(  );
	void DaoWrap_drawtext( int _cp0, int _cp1, int _cp2, int _cp3 ){ Fl_Input_::drawtext( _cp0, _cp1, _cp2, _cp3 ); }
	void DaoWrap_handle_mouse( int _cp0, int _cp1, int _cp2, int _cp3, int keepmark=0 ){ Fl_Input_::handle_mouse( _cp0, _cp1, _cp2, _cp3, keepmark ); }
	int DaoWrap_handletext( int e, int _cp1, int _cp2, int _cp3, int _cp4 ){ return Fl_Input_::handletext( e, _cp1, _cp2, _cp3, _cp4 ); }
	int DaoWrap_line_end( int i )const{ return Fl_Input_::line_end( i ); }
	int DaoWrap_line_start( int i )const{ return Fl_Input_::line_start( i ); }
	int DaoWrap_linesPerPage(  ){ return Fl_Input_::linesPerPage(  ); }
	void DaoWrap_maybe_do_callback(  ){ Fl_Input_::maybe_do_callback(  ); }
	void resize( int _cp0, int _cp1, int _cp2, int _cp3 );
	int DaoWrap_up_down_position( int _cp0, int keepmark=0 ){ return Fl_Input_::up_down_position( _cp0, keepmark ); }
	int DaoWrap_word_end( int i )const{ return Fl_Input_::word_end( i ); }
	int DaoWrap_word_start( int i )const{ return Fl_Input_::word_start( i ); }
	int DaoWrap_xscroll(  )const{ return Fl_Input_::xscroll(  ); }
	int DaoWrap_yscroll(  )const{ return Fl_Input_::yscroll(  ); }
	void DaoWrap_yscroll( int y ){ Fl_Input_::yscroll( y ); }
};
DaoCxx_Fl_Input_* DAO_DLL_FLTK DaoCxx_Fl_Input__New( int _cp0, int _cp1, int _cp2, int _cp3, const char* _cp4 );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Input  : public DaoCxxVirt_Fl_Input_
{
	public:
	DaoCxxVirt_Fl_Input(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Input *self, DaoCData *d );
	Fl_Input *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Input : public Fl_Input, public DaoCxxVirt_Fl_Input
{ 
	public:
   DaoCxx_Fl_Input( int _cp0, int _cp1, int _cp2, int _cp3, const char* _cp4 = 0 ) : Fl_Input( _cp0, _cp1, _cp2, _cp3, _cp4 ){}
	~DaoCxx_Fl_Input();
	void DaoInitWrapper();
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Input::draw(  ); }
	int handle( int _cp0 );
};
DaoCxx_Fl_Input* DAO_DLL_FLTK DaoCxx_Fl_Input_New( int _cp0, int _cp1, int _cp2, int _cp3, const char* _cp4 );

class DAO_DLL_FLTK DaoCxxVirt_Fl_File_Input  : public DaoCxxVirt_Fl_Input
{
	public:
	DaoCxxVirt_Fl_File_Input(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_File_Input *self, DaoCData *d );
	Fl_File_Input *self;
	DaoCData *cdata;
	void draw( int &_cs  );
	int handle( int &_cs, int event );

};
class DAO_DLL_FLTK DaoCxx_Fl_File_Input : public Fl_File_Input, public DaoCxxVirt_Fl_File_Input
{ 
	public:
   DaoCxx_Fl_File_Input( int X, int Y, int W, int H, const char* L=0 ) : Fl_File_Input( X, Y, W, H, L ){}
	~DaoCxx_Fl_File_Input();
	void DaoInitWrapper();
	void draw(  );
	int handle( int event );
	void DaoWrap_draw(  ){ Fl_File_Input::draw(  ); }
};
DaoCxx_Fl_File_Input* DAO_DLL_FLTK DaoCxx_Fl_File_Input_New( int X, int Y, int W, int H, const char* L );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Fill_Dial  : public DaoCxxVirt_Fl_Dial
{
	public:
	DaoCxxVirt_Fl_Fill_Dial(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Fill_Dial *self, DaoCData *d );
	Fl_Fill_Dial *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Fill_Dial : public Fl_Fill_Dial, public DaoCxxVirt_Fl_Fill_Dial
{ 
	public:
   DaoCxx_Fl_Fill_Dial( int x, int y, int w, int h, const char* l = 0 ) : Fl_Fill_Dial( x, y, w, h, l ){}
	~DaoCxx_Fl_Fill_Dial();
	void DaoInitWrapper();

};
DaoCxx_Fl_Fill_Dial* DAO_DLL_FLTK DaoCxx_Fl_Fill_Dial_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Slider  : public DaoCxxVirt_Fl_Valuator
{
	public:
	DaoCxxVirt_Fl_Slider(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Slider *self, DaoCData *d );
	Fl_Slider *self;
	DaoCData *cdata;
	int format( int &_cs, char* _cp0 );
	void value_damage( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Slider : public Fl_Slider, public DaoCxxVirt_Fl_Slider
{ 
	public:
   DaoCxx_Fl_Slider( int X, int Y, int W, int H, const char* L = 0 ) : Fl_Slider( X, Y, W, H, L ){}
   DaoCxx_Fl_Slider( uchar t, int X, int Y, int W, int H, const char* L ) : Fl_Slider( t, X, Y, W, H, L ){}
	~DaoCxx_Fl_Slider();
	void DaoInitWrapper();
	int format( char* _cp0 );
	void value_damage(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Slider::draw(  ); }
	void DaoWrap_draw( int _cp0, int _cp1, int _cp2, int _cp3 ){ Fl_Slider::draw( _cp0, _cp1, _cp2, _cp3 ); }
	int handle( int _cp0 );
	int DaoWrap_handle( int _cp0, int _cp1, int _cp2, int _cp3, int _cp4 ){ return Fl_Slider::handle( _cp0, _cp1, _cp2, _cp3, _cp4 ); }
};
DaoCxx_Fl_Slider* DAO_DLL_FLTK DaoCxx_Fl_Slider_New( int X, int Y, int W, int H, const char* L );
DaoCxx_Fl_Slider* DAO_DLL_FLTK DaoCxx_Fl_Slider_New( uchar t, int X, int Y, int W, int H, const char* L );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Fill_Slider  : public DaoCxxVirt_Fl_Slider
{
	public:
	DaoCxxVirt_Fl_Fill_Slider(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Fill_Slider *self, DaoCData *d );
	Fl_Fill_Slider *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Fill_Slider : public Fl_Fill_Slider, public DaoCxxVirt_Fl_Fill_Slider
{ 
	public:
   DaoCxx_Fl_Fill_Slider( int x, int y, int w, int h, const char* l=0 ) : Fl_Fill_Slider( x, y, w, h, l ){}
	~DaoCxx_Fl_Fill_Slider();
	void DaoInitWrapper();

};
DaoCxx_Fl_Fill_Slider* DAO_DLL_FLTK DaoCxx_Fl_Fill_Slider_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Float_Input  : public DaoCxxVirt_Fl_Input
{
	public:
	DaoCxxVirt_Fl_Float_Input(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Float_Input *self, DaoCData *d );
	Fl_Float_Input *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Float_Input : public Fl_Float_Input, public DaoCxxVirt_Fl_Float_Input
{ 
	public:
   DaoCxx_Fl_Float_Input( int X, int Y, int W, int H, const char* l = 0 ) : Fl_Float_Input( X, Y, W, H, l ){}
	~DaoCxx_Fl_Float_Input();
	void DaoInitWrapper();

};
DaoCxx_Fl_Float_Input* DAO_DLL_FLTK DaoCxx_Fl_Float_Input_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_FormsBitmap  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Fl_FormsBitmap(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_FormsBitmap *self, DaoCData *d );
	Fl_FormsBitmap *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	int handle( int &_cs, int event );
	void hide( int &_cs  );
	void resize( int &_cs, int x, int y, int w, int h );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_FormsBitmap : public Fl_FormsBitmap, public DaoCxxVirt_Fl_FormsBitmap
{ 
	public:
   DaoCxx_Fl_FormsBitmap( Fl_Boxtype _cp0, int _cp1, int _cp2, int _cp3, int _cp4, const char* _cp5 = 0 ) : Fl_FormsBitmap( _cp0, _cp1, _cp2, _cp3, _cp4, _cp5 ){}
	~DaoCxx_Fl_FormsBitmap();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	int handle( int event );
	void hide(  );
	void resize( int x, int y, int w, int h );
	void show(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_FormsBitmap::draw(  ); }
};
DaoCxx_Fl_FormsBitmap* DAO_DLL_FLTK DaoCxx_Fl_FormsBitmap_New( Fl_Boxtype _cp0, int _cp1, int _cp2, int _cp3, int _cp4, const char* _cp5 );

class DAO_DLL_FLTK DaoCxxVirt_Fl_FormsPixmap  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Fl_FormsPixmap(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_FormsPixmap *self, DaoCData *d );
	Fl_FormsPixmap *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	int handle( int &_cs, int event );
	void hide( int &_cs  );
	void resize( int &_cs, int x, int y, int w, int h );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_FormsPixmap : public Fl_FormsPixmap, public DaoCxxVirt_Fl_FormsPixmap
{ 
	public:
   DaoCxx_Fl_FormsPixmap( Fl_Boxtype t, int X, int Y, int W, int H, const char* L= 0 ) : Fl_FormsPixmap( t, X, Y, W, H, L ){}
	~DaoCxx_Fl_FormsPixmap();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	int handle( int event );
	void hide(  );
	void resize( int x, int y, int w, int h );
	void show(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_FormsPixmap::draw(  ); }
};
DaoCxx_Fl_FormsPixmap* DAO_DLL_FLTK DaoCxx_Fl_FormsPixmap_New( Fl_Boxtype t, int X, int Y, int W, int H, const char* L );

class DAO_DLL_FLTK DaoCxxVirt_Fl_FormsText  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Fl_FormsText(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_FormsText *self, DaoCData *d );
	Fl_FormsText *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	int handle( int &_cs, int event );
	void hide( int &_cs  );
	void resize( int &_cs, int x, int y, int w, int h );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_FormsText : public Fl_FormsText, public DaoCxxVirt_Fl_FormsText
{ 
	public:
   DaoCxx_Fl_FormsText( Fl_Boxtype b, int X, int Y, int W, int H, const char* l=0 ) : Fl_FormsText( b, X, Y, W, H, l ){}
	~DaoCxx_Fl_FormsText();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	int handle( int event );
	void hide(  );
	void resize( int x, int y, int w, int h );
	void show(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_FormsText::draw(  ); }
};
DaoCxx_Fl_FormsText* DAO_DLL_FLTK DaoCxx_Fl_FormsText_New( Fl_Boxtype b, int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Free  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Fl_Free(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Free *self, DaoCData *d );
	Fl_Free *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	void hide( int &_cs  );
	void resize( int &_cs, int x, int y, int w, int h );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Free : public Fl_Free, public DaoCxxVirt_Fl_Free
{ 
	public:
	~DaoCxx_Fl_Free();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	void hide(  );
	void resize( int x, int y, int w, int h );
	void show(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Free::draw(  ); }
	int handle( int e );
};


Fl_GIF_Image* DAO_DLL_FLTK Dao_Fl_GIF_Image_New( const char* filename );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Gl_Window  : public DaoCxxVirt_Fl_Window
{
	public:
	DaoCxxVirt_Fl_Gl_Window(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Gl_Window *self, DaoCData *d );
	Fl_Gl_Window *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void draw( int &_cs  );
	int handle( int &_cs, int _cp0 );

};
class DAO_DLL_FLTK DaoCxx_Fl_Gl_Window : public Fl_Gl_Window, public DaoCxxVirt_Fl_Gl_Window
{ 
	public:
   DaoCxx_Fl_Gl_Window( int W, int H, const char* l=0 ) : Fl_Gl_Window( W, H, l ){}
   DaoCxx_Fl_Gl_Window( int X, int Y, int W, int H, const char* l=0 ) : Fl_Gl_Window( X, Y, W, H, l ){}
	~DaoCxx_Fl_Gl_Window();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Window* as_window(  );
	void draw(  );
	int handle( int _cp0 );
	void DaoWrap_draw(  ){ Fl_Gl_Window::draw(  ); }
	void flush(  );
	void hide(  );
	void resize( int _cp0, int _cp1, int _cp2, int _cp3 );
	void show(  );
};
DaoCxx_Fl_Gl_Window* DAO_DLL_FLTK DaoCxx_Fl_Gl_Window_New( int W, int H, const char* l );
DaoCxx_Fl_Gl_Window* DAO_DLL_FLTK DaoCxx_Fl_Gl_Window_New( int X, int Y, int W, int H, const char* l );

Fl_Glut_Bitmap_Font* DAO_DLL_FLTK Dao_Fl_Glut_Bitmap_Font_New();

Fl_Glut_StrokeChar* DAO_DLL_FLTK Dao_Fl_Glut_StrokeChar_New();

Fl_Glut_StrokeFont* DAO_DLL_FLTK Dao_Fl_Glut_StrokeFont_New();

Fl_Glut_StrokeStrip* DAO_DLL_FLTK Dao_Fl_Glut_StrokeStrip_New();

Fl_Glut_StrokeVertex* DAO_DLL_FLTK Dao_Fl_Glut_StrokeVertex_New();

class DAO_DLL_FLTK DaoCxxVirt_Fl_Glut_Window  : public DaoCxxVirt_Fl_Gl_Window
{
	public:
	DaoCxxVirt_Fl_Glut_Window(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Glut_Window *self, DaoCData *d );
	Fl_Glut_Window *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Glut_Window : public Fl_Glut_Window, public DaoCxxVirt_Fl_Glut_Window
{ 
	public:
   DaoCxx_Fl_Glut_Window( int w, int h, const char* _cp2 ) : Fl_Glut_Window( w, h, _cp2 ){}
   DaoCxx_Fl_Glut_Window( int x, int y, int w, int h, const char* _cp4 ) : Fl_Glut_Window( x, y, w, h, _cp4 ){}
	~DaoCxx_Fl_Glut_Window();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Glut_Window::draw(  ); }
	void DaoWrap_draw_overlay(  ){ Fl_Glut_Window::draw_overlay(  ); }
	int handle( int _cp0 );
	int DaoWrap_handle( int _cp0 ){ return Fl_Glut_Window::handle( _cp0 ); }
};
DaoCxx_Fl_Glut_Window* DAO_DLL_FLTK DaoCxx_Fl_Glut_Window_New( int w, int h, const char* _cp2 );
DaoCxx_Fl_Glut_Window* DAO_DLL_FLTK DaoCxx_Fl_Glut_Window_New( int x, int y, int w, int h, const char* _cp4 );

Fl_Help_Block* DAO_DLL_FLTK Dao_Fl_Help_Block_New();


Fl_Help_Dialog* DAO_DLL_FLTK Dao_Fl_Help_Dialog_New(  );


Fl_Help_Font_Stack* DAO_DLL_FLTK Dao_Fl_Help_Font_Stack_New(  );


Fl_Help_Font_Style* DAO_DLL_FLTK Dao_Fl_Help_Font_Style_New(  );
Fl_Help_Font_Style* DAO_DLL_FLTK Dao_Fl_Help_Font_Style_New( Fl_Font afont, Fl_Fontsize asize, Fl_Color acolor );

Fl_Help_Link* DAO_DLL_FLTK Dao_Fl_Help_Link_New();

Fl_Help_Target* DAO_DLL_FLTK Dao_Fl_Help_Target_New();

class DAO_DLL_FLTK DaoCxxVirt_Fl_Help_View  : public DaoCxxVirt_Fl_Group
{
	public:
	DaoCxxVirt_Fl_Help_View(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Help_View *self, DaoCData *d );
	Fl_Help_View *self;
	DaoCData *cdata;
	Fl_Group* as_group( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Help_View : public Fl_Help_View, public DaoCxxVirt_Fl_Help_View
{ 
	public:
   DaoCxx_Fl_Help_View( int xx, int yy, int ww, int hh, const char* l = 0 ) : Fl_Help_View( xx, yy, ww, hh, l ){}
	~DaoCxx_Fl_Help_View();
	void DaoInitWrapper();
	Fl_Group* as_group(  );
	void resize( int _cp0, int _cp1, int _cp2, int _cp3 );
};
DaoCxx_Fl_Help_View* DAO_DLL_FLTK DaoCxx_Fl_Help_View_New( int xx, int yy, int ww, int hh, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Hold_Browser  : public DaoCxxVirt_Fl_Browser
{
	public:
	DaoCxxVirt_Fl_Hold_Browser(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Hold_Browser *self, DaoCData *d );
	Fl_Hold_Browser *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Hold_Browser : public Fl_Hold_Browser, public DaoCxxVirt_Fl_Hold_Browser
{ 
	public:
   DaoCxx_Fl_Hold_Browser( int X, int Y, int W, int H, const char* l=0 ) : Fl_Hold_Browser( X, Y, W, H, l ){}
	~DaoCxx_Fl_Hold_Browser();
	void DaoInitWrapper();

};
DaoCxx_Fl_Hold_Browser* DAO_DLL_FLTK DaoCxx_Fl_Hold_Browser_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Hor_Fill_Slider  : public DaoCxxVirt_Fl_Slider
{
	public:
	DaoCxxVirt_Fl_Hor_Fill_Slider(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Hor_Fill_Slider *self, DaoCData *d );
	Fl_Hor_Fill_Slider *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Hor_Fill_Slider : public Fl_Hor_Fill_Slider, public DaoCxxVirt_Fl_Hor_Fill_Slider
{ 
	public:
   DaoCxx_Fl_Hor_Fill_Slider( int x, int y, int w, int h, const char* l=0 ) : Fl_Hor_Fill_Slider( x, y, w, h, l ){}
	~DaoCxx_Fl_Hor_Fill_Slider();
	void DaoInitWrapper();

};
DaoCxx_Fl_Hor_Fill_Slider* DAO_DLL_FLTK DaoCxx_Fl_Hor_Fill_Slider_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Hor_Nice_Slider  : public DaoCxxVirt_Fl_Slider
{
	public:
	DaoCxxVirt_Fl_Hor_Nice_Slider(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Hor_Nice_Slider *self, DaoCData *d );
	Fl_Hor_Nice_Slider *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Hor_Nice_Slider : public Fl_Hor_Nice_Slider, public DaoCxxVirt_Fl_Hor_Nice_Slider
{ 
	public:
   DaoCxx_Fl_Hor_Nice_Slider( int x, int y, int w, int h, const char* l=0 ) : Fl_Hor_Nice_Slider( x, y, w, h, l ){}
	~DaoCxx_Fl_Hor_Nice_Slider();
	void DaoInitWrapper();

};
DaoCxx_Fl_Hor_Nice_Slider* DAO_DLL_FLTK DaoCxx_Fl_Hor_Nice_Slider_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Hor_Slider  : public DaoCxxVirt_Fl_Slider
{
	public:
	DaoCxxVirt_Fl_Hor_Slider(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Hor_Slider *self, DaoCData *d );
	Fl_Hor_Slider *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Hor_Slider : public Fl_Hor_Slider, public DaoCxxVirt_Fl_Hor_Slider
{ 
	public:
   DaoCxx_Fl_Hor_Slider( int X, int Y, int W, int H, const char* l=0 ) : Fl_Hor_Slider( X, Y, W, H, l ){}
	~DaoCxx_Fl_Hor_Slider();
	void DaoInitWrapper();

};
DaoCxx_Fl_Hor_Slider* DAO_DLL_FLTK DaoCxx_Fl_Hor_Slider_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Value_Slider  : public DaoCxxVirt_Fl_Slider
{
	public:
	DaoCxxVirt_Fl_Value_Slider(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Value_Slider *self, DaoCData *d );
	Fl_Value_Slider *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Value_Slider : public Fl_Value_Slider, public DaoCxxVirt_Fl_Value_Slider
{ 
	public:
   DaoCxx_Fl_Value_Slider( int x, int y, int w, int h, const char* l = 0 ) : Fl_Value_Slider( x, y, w, h, l ){}
	~DaoCxx_Fl_Value_Slider();
	void DaoInitWrapper();
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Value_Slider::draw(  ); }
	int handle( int _cp0 );
};
DaoCxx_Fl_Value_Slider* DAO_DLL_FLTK DaoCxx_Fl_Value_Slider_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Hor_Value_Slider  : public DaoCxxVirt_Fl_Value_Slider
{
	public:
	DaoCxxVirt_Fl_Hor_Value_Slider(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Hor_Value_Slider *self, DaoCData *d );
	Fl_Hor_Value_Slider *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Hor_Value_Slider : public Fl_Hor_Value_Slider, public DaoCxxVirt_Fl_Hor_Value_Slider
{ 
	public:
   DaoCxx_Fl_Hor_Value_Slider( int X, int Y, int W, int H, const char* l=0 ) : Fl_Hor_Value_Slider( X, Y, W, H, l ){}
	~DaoCxx_Fl_Hor_Value_Slider();
	void DaoInitWrapper();

};
DaoCxx_Fl_Hor_Value_Slider* DAO_DLL_FLTK DaoCxx_Fl_Hor_Value_Slider_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Input_Choice  : public DaoCxxVirt_Fl_Group
{
	public:
	DaoCxxVirt_Fl_Input_Choice(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Input_Choice *self, DaoCData *d );
	Fl_Input_Choice *self;
	DaoCData *cdata;
	Fl_Group* as_group( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Input_Choice : public Fl_Input_Choice, public DaoCxxVirt_Fl_Input_Choice
{ 
	public:
   DaoCxx_Fl_Input_Choice( int x, int y, int w, int h, const char* l=0 ) : Fl_Input_Choice( x, y, w, h, l ){}
	~DaoCxx_Fl_Input_Choice();
	void DaoInitWrapper();
	Fl_Group* as_group(  );
	void resize( int X, int Y, int W, int H );
};
DaoCxx_Fl_Input_Choice* DAO_DLL_FLTK DaoCxx_Fl_Input_Choice_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Int_Input  : public DaoCxxVirt_Fl_Input
{
	public:
	DaoCxxVirt_Fl_Int_Input(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Int_Input *self, DaoCData *d );
	Fl_Int_Input *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Int_Input : public Fl_Int_Input, public DaoCxxVirt_Fl_Int_Input
{ 
	public:
   DaoCxx_Fl_Int_Input( int X, int Y, int W, int H, const char* l = 0 ) : Fl_Int_Input( X, Y, W, H, l ){}
	~DaoCxx_Fl_Int_Input();
	void DaoInitWrapper();

};
DaoCxx_Fl_Int_Input* DAO_DLL_FLTK DaoCxx_Fl_Int_Input_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_JPEG_Image  : public DaoCxxVirt_Fl_RGB_Image
{
	public:
	DaoCxxVirt_Fl_JPEG_Image(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_JPEG_Image *self, DaoCData *d );
	Fl_JPEG_Image *self;
	DaoCData *cdata;
	void color_average( int &_cs, Fl_Color c, float i );
	Fl_Image* copy( int &_cs, int W, int H );
	void desaturate( int &_cs  );
	void draw( int &_cs, int X, int Y, int W, int H, int cx, int cy );
	void label( int &_cs, Fl_Menu_Item* m );
	void label( int &_cs, Fl_Widget* w );
	void uncache( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_JPEG_Image : public Fl_JPEG_Image, public DaoCxxVirt_Fl_JPEG_Image
{ 
	public:
   DaoCxx_Fl_JPEG_Image( const char* filename ) : Fl_JPEG_Image( filename ){}
   DaoCxx_Fl_JPEG_Image( const char* name, const unsigned char* data ) : Fl_JPEG_Image( name, data ){}
	~DaoCxx_Fl_JPEG_Image();
	void DaoInitWrapper();
	void color_average( Fl_Color c, float i );
	Fl_Image* copy( int W, int H );
	void desaturate(  );
	void draw( int X, int Y, int W, int H, int cx=0, int cy=0 );
	void label( Fl_Menu_Item* m );
	void label( Fl_Widget* w );
	void uncache(  );
};
DaoCxx_Fl_JPEG_Image* DAO_DLL_FLTK DaoCxx_Fl_JPEG_Image_New( const char* filename );
DaoCxx_Fl_JPEG_Image* DAO_DLL_FLTK DaoCxx_Fl_JPEG_Image_New( const char* name, const unsigned char* data );

Fl_Label* DAO_DLL_FLTK Dao_Fl_Label_New();

class DAO_DLL_FLTK DaoCxxVirt_Fl_Line_Dial  : public DaoCxxVirt_Fl_Dial
{
	public:
	DaoCxxVirt_Fl_Line_Dial(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Line_Dial *self, DaoCData *d );
	Fl_Line_Dial *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Line_Dial : public Fl_Line_Dial, public DaoCxxVirt_Fl_Line_Dial
{ 
	public:
   DaoCxx_Fl_Line_Dial( int x, int y, int w, int h, const char* l = 0 ) : Fl_Line_Dial( x, y, w, h, l ){}
	~DaoCxx_Fl_Line_Dial();
	void DaoInitWrapper();

};
DaoCxx_Fl_Line_Dial* DAO_DLL_FLTK DaoCxx_Fl_Line_Dial_New( int x, int y, int w, int h, const char* l );

Fl_Menu_Item* DAO_DLL_FLTK Dao_Fl_Menu_Item_New();

class DAO_DLL_FLTK DaoCxxVirt_Fl_Menu_Bar  : public DaoCxxVirt_Fl_Menu_
{
	public:
	DaoCxxVirt_Fl_Menu_Bar(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Menu_Bar *self, DaoCData *d );
	Fl_Menu_Bar *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Menu_Bar : public Fl_Menu_Bar, public DaoCxxVirt_Fl_Menu_Bar
{ 
	public:
   DaoCxx_Fl_Menu_Bar( int X, int Y, int W, int H, const char* l=0 ) : Fl_Menu_Bar( X, Y, W, H, l ){}
	~DaoCxx_Fl_Menu_Bar();
	void DaoInitWrapper();
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Menu_Bar::draw(  ); }
	int handle( int _cp0 );
};
DaoCxx_Fl_Menu_Bar* DAO_DLL_FLTK DaoCxx_Fl_Menu_Bar_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Menu_Button  : public DaoCxxVirt_Fl_Menu_
{
	public:
	DaoCxxVirt_Fl_Menu_Button(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Menu_Button *self, DaoCData *d );
	Fl_Menu_Button *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Menu_Button : public Fl_Menu_Button, public DaoCxxVirt_Fl_Menu_Button
{ 
	public:
   DaoCxx_Fl_Menu_Button( int _cp0, int _cp1, int _cp2, int _cp3, const char* _cp4 =0 ) : Fl_Menu_Button( _cp0, _cp1, _cp2, _cp3, _cp4 ){}
	~DaoCxx_Fl_Menu_Button();
	void DaoInitWrapper();
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Menu_Button::draw(  ); }
	int handle( int _cp0 );
};
DaoCxx_Fl_Menu_Button* DAO_DLL_FLTK DaoCxx_Fl_Menu_Button_New( int _cp0, int _cp1, int _cp2, int _cp3, const char* _cp4 );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Single_Window  : public DaoCxxVirt_Fl_Window
{
	public:
	DaoCxxVirt_Fl_Single_Window(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Single_Window *self, DaoCData *d );
	Fl_Single_Window *self;
	DaoCData *cdata;
	Fl_Window* as_window( int &_cs  );
	void draw( int &_cs  );
	int handle( int &_cs, int _cp0 );
	void hide( int &_cs  );
	void resize( int &_cs, int _cp0, int _cp1, int _cp2, int _cp3 );

};
class DAO_DLL_FLTK DaoCxx_Fl_Single_Window : public Fl_Single_Window, public DaoCxxVirt_Fl_Single_Window
{ 
	public:
   DaoCxx_Fl_Single_Window( int W, int H, const char* l=0 ) : Fl_Single_Window( W, H, l ){}
   DaoCxx_Fl_Single_Window( int X, int Y, int W, int H, const char* l=0 ) : Fl_Single_Window( X, Y, W, H, l ){}
	~DaoCxx_Fl_Single_Window();
	void DaoInitWrapper();
	Fl_Window* as_window(  );
	void draw(  );
	int handle( int _cp0 );
	void hide(  );
	void resize( int _cp0, int _cp1, int _cp2, int _cp3 );
	void flush(  );
	void show(  );
};
DaoCxx_Fl_Single_Window* DAO_DLL_FLTK DaoCxx_Fl_Single_Window_New( int W, int H, const char* l );
DaoCxx_Fl_Single_Window* DAO_DLL_FLTK DaoCxx_Fl_Single_Window_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Menu_Window  : public DaoCxxVirt_Fl_Single_Window
{
	public:
	DaoCxxVirt_Fl_Menu_Window(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Menu_Window *self, DaoCData *d );
	Fl_Menu_Window *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Menu_Window : public Fl_Menu_Window, public DaoCxxVirt_Fl_Menu_Window
{ 
	public:
   DaoCxx_Fl_Menu_Window( int W, int H, const char* l = 0 ) : Fl_Menu_Window( W, H, l ){}
   DaoCxx_Fl_Menu_Window( int X, int Y, int W, int H, const char* l = 0 ) : Fl_Menu_Window( X, Y, W, H, l ){}
	~DaoCxx_Fl_Menu_Window();
	void DaoInitWrapper();
	void flush(  );
	void hide(  );
	void show(  );
};
DaoCxx_Fl_Menu_Window* DAO_DLL_FLTK DaoCxx_Fl_Menu_Window_New( int W, int H, const char* l );
DaoCxx_Fl_Menu_Window* DAO_DLL_FLTK DaoCxx_Fl_Menu_Window_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Multi_Browser  : public DaoCxxVirt_Fl_Browser
{
	public:
	DaoCxxVirt_Fl_Multi_Browser(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Multi_Browser *self, DaoCData *d );
	Fl_Multi_Browser *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Multi_Browser : public Fl_Multi_Browser, public DaoCxxVirt_Fl_Multi_Browser
{ 
	public:
   DaoCxx_Fl_Multi_Browser( int X, int Y, int W, int H, const char* L=0 ) : Fl_Multi_Browser( X, Y, W, H, L ){}
	~DaoCxx_Fl_Multi_Browser();
	void DaoInitWrapper();

};
DaoCxx_Fl_Multi_Browser* DAO_DLL_FLTK DaoCxx_Fl_Multi_Browser_New( int X, int Y, int W, int H, const char* L );

Fl_Multi_Label* DAO_DLL_FLTK Dao_Fl_Multi_Label_New();

class DAO_DLL_FLTK DaoCxxVirt_Fl_Multiline_Input  : public DaoCxxVirt_Fl_Input
{
	public:
	DaoCxxVirt_Fl_Multiline_Input(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Multiline_Input *self, DaoCData *d );
	Fl_Multiline_Input *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Multiline_Input : public Fl_Multiline_Input, public DaoCxxVirt_Fl_Multiline_Input
{ 
	public:
   DaoCxx_Fl_Multiline_Input( int X, int Y, int W, int H, const char* l = 0 ) : Fl_Multiline_Input( X, Y, W, H, l ){}
	~DaoCxx_Fl_Multiline_Input();
	void DaoInitWrapper();

};
DaoCxx_Fl_Multiline_Input* DAO_DLL_FLTK DaoCxx_Fl_Multiline_Input_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Output  : public DaoCxxVirt_Fl_Input
{
	public:
	DaoCxxVirt_Fl_Output(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Output *self, DaoCData *d );
	Fl_Output *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Output : public Fl_Output, public DaoCxxVirt_Fl_Output
{ 
	public:
   DaoCxx_Fl_Output( int X, int Y, int W, int H, const char* l = 0 ) : Fl_Output( X, Y, W, H, l ){}
	~DaoCxx_Fl_Output();
	void DaoInitWrapper();

};
DaoCxx_Fl_Output* DAO_DLL_FLTK DaoCxx_Fl_Output_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Multiline_Output  : public DaoCxxVirt_Fl_Output
{
	public:
	DaoCxxVirt_Fl_Multiline_Output(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Multiline_Output *self, DaoCData *d );
	Fl_Multiline_Output *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Multiline_Output : public Fl_Multiline_Output, public DaoCxxVirt_Fl_Multiline_Output
{ 
	public:
   DaoCxx_Fl_Multiline_Output( int X, int Y, int W, int H, const char* l = 0 ) : Fl_Multiline_Output( X, Y, W, H, l ){}
	~DaoCxx_Fl_Multiline_Output();
	void DaoInitWrapper();

};
DaoCxx_Fl_Multiline_Output* DAO_DLL_FLTK DaoCxx_Fl_Multiline_Output_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Nice_Slider  : public DaoCxxVirt_Fl_Slider
{
	public:
	DaoCxxVirt_Fl_Nice_Slider(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Nice_Slider *self, DaoCData *d );
	Fl_Nice_Slider *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Nice_Slider : public Fl_Nice_Slider, public DaoCxxVirt_Fl_Nice_Slider
{ 
	public:
   DaoCxx_Fl_Nice_Slider( int x, int y, int w, int h, const char* l=0 ) : Fl_Nice_Slider( x, y, w, h, l ){}
	~DaoCxx_Fl_Nice_Slider();
	void DaoInitWrapper();

};
DaoCxx_Fl_Nice_Slider* DAO_DLL_FLTK DaoCxx_Fl_Nice_Slider_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_PNG_Image  : public DaoCxxVirt_Fl_RGB_Image
{
	public:
	DaoCxxVirt_Fl_PNG_Image(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_PNG_Image *self, DaoCData *d );
	Fl_PNG_Image *self;
	DaoCData *cdata;
	void color_average( int &_cs, Fl_Color c, float i );
	Fl_Image* copy( int &_cs, int W, int H );
	void desaturate( int &_cs  );
	void draw( int &_cs, int X, int Y, int W, int H, int cx, int cy );
	void label( int &_cs, Fl_Menu_Item* m );
	void label( int &_cs, Fl_Widget* w );
	void uncache( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_PNG_Image : public Fl_PNG_Image, public DaoCxxVirt_Fl_PNG_Image
{ 
	public:
   DaoCxx_Fl_PNG_Image( const char* filename ) : Fl_PNG_Image( filename ){}
	~DaoCxx_Fl_PNG_Image();
	void DaoInitWrapper();
	void color_average( Fl_Color c, float i );
	Fl_Image* copy( int W, int H );
	void desaturate(  );
	void draw( int X, int Y, int W, int H, int cx=0, int cy=0 );
	void label( Fl_Menu_Item* m );
	void label( Fl_Widget* w );
	void uncache(  );
};
DaoCxx_Fl_PNG_Image* DAO_DLL_FLTK DaoCxx_Fl_PNG_Image_New( const char* filename );

class DAO_DLL_FLTK DaoCxxVirt_Fl_PNM_Image  : public DaoCxxVirt_Fl_RGB_Image
{
	public:
	DaoCxxVirt_Fl_PNM_Image(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_PNM_Image *self, DaoCData *d );
	Fl_PNM_Image *self;
	DaoCData *cdata;
	void color_average( int &_cs, Fl_Color c, float i );
	Fl_Image* copy( int &_cs, int W, int H );
	void desaturate( int &_cs  );
	void draw( int &_cs, int X, int Y, int W, int H, int cx, int cy );
	void label( int &_cs, Fl_Menu_Item* m );
	void label( int &_cs, Fl_Widget* w );
	void uncache( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_PNM_Image : public Fl_PNM_Image, public DaoCxxVirt_Fl_PNM_Image
{ 
	public:
   DaoCxx_Fl_PNM_Image( const char* filename ) : Fl_PNM_Image( filename ){}
	~DaoCxx_Fl_PNM_Image();
	void DaoInitWrapper();
	void color_average( Fl_Color c, float i );
	Fl_Image* copy( int W, int H );
	void desaturate(  );
	void draw( int X, int Y, int W, int H, int cx=0, int cy=0 );
	void label( Fl_Menu_Item* m );
	void label( Fl_Widget* w );
	void uncache(  );
};
DaoCxx_Fl_PNM_Image* DAO_DLL_FLTK DaoCxx_Fl_PNM_Image_New( const char* filename );

class DAO_DLL_FLTK DaoCxxVirt_Fl_PSfile_Device  : public DaoCxxVirt_Fl_Abstract_Printer
{
	public:
	DaoCxxVirt_Fl_PSfile_Device(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_PSfile_Device *self, DaoCData *d );
	Fl_PSfile_Device *self;
	DaoCData *cdata;
	int start_job( int &_cs, int pagecount, int* frompage, int* topage );

};
class DAO_DLL_FLTK DaoCxx_Fl_PSfile_Device : public Fl_PSfile_Device, public DaoCxxVirt_Fl_PSfile_Device
{ 
	public:
   DaoCxx_Fl_PSfile_Device(  ) : Fl_PSfile_Device(  ){}
	~DaoCxx_Fl_PSfile_Device();
	void DaoInitWrapper();
	int start_job( int pagecount, int* frompage = NULL, int* topage = NULL );
	int DaoWrap_alpha_mask( const uchar* data, int w, int h, int D, int LD=0 ){ return Fl_PSfile_Device::alpha_mask( data, w, h, D, LD ); }
	void arc( double x, double y, double r, double start, double a );
	void DaoWrap_arc( double x, double y, double r, double start, double a ){ Fl_PSfile_Device::arc( x, y, r, start, a ); }
	void arc( int x, int y, int w, int h, double a1, double a2 );
	void DaoWrap_arc( int x, int y, int w, int h, double a1, double a2 ){ Fl_PSfile_Device::arc( x, y, w, h, a1, a2 ); }
	void begin_complex_polygon(  );
	void DaoWrap_begin_complex_polygon(  ){ Fl_PSfile_Device::begin_complex_polygon(  ); }
	void begin_line(  );
	void DaoWrap_begin_line(  ){ Fl_PSfile_Device::begin_line(  ); }
	void begin_loop(  );
	void DaoWrap_begin_loop(  ){ Fl_PSfile_Device::begin_loop(  ); }
	void begin_points(  );
	void DaoWrap_begin_points(  ){ Fl_PSfile_Device::begin_points(  ); }
	void begin_polygon(  );
	void DaoWrap_begin_polygon(  ){ Fl_PSfile_Device::begin_polygon(  ); }
	void circle( double x, double y, double r );
	void DaoWrap_circle( double x, double y, double r ){ Fl_PSfile_Device::circle( x, y, r ); }
	int clip_box( int x, int y, int w, int h, int& X, int& Y, int& W, int& H );
	int DaoWrap_clip_box( int x, int y, int w, int h, int& X, int& Y, int& W, int& H ){ return Fl_PSfile_Device::clip_box( x, y, w, h, X, Y, W, H ); }
	Fl_Color DaoWrap_color(  ){ return Fl_PSfile_Device::color(  ); }
	void color( Fl_Color c );
	void DaoWrap_color( Fl_Color c ){ Fl_PSfile_Device::color( c ); }
	void color( uchar r, uchar g, uchar b );
	void DaoWrap_color( uchar r, uchar g, uchar b ){ Fl_PSfile_Device::color( r, g, b ); }
	void curve( double x, double y, double x1, double y1, double x2, double y2, double x3, double y3 );
	void DaoWrap_curve( double x, double y, double x1, double y1, double x2, double y2, double x3, double y3 ){ Fl_PSfile_Device::curve( x, y, x1, y1, x2, y2, x3, y3 ); }
	void draw( Fl_Bitmap* bitmap, int XP, int YP, int WP, int HP, int cx, int cy );
	void DaoWrap_draw( Fl_Bitmap* bitmap, int XP, int YP, int WP, int HP, int cx, int cy ){ Fl_PSfile_Device::draw( bitmap, XP, YP, WP, HP, cx, cy ); }
	void draw( Fl_Pixmap* pxm, int XP, int YP, int WP, int HP, int cx, int cy );
	void DaoWrap_draw( Fl_Pixmap* pxm, int XP, int YP, int WP, int HP, int cx, int cy ){ Fl_PSfile_Device::draw( pxm, XP, YP, WP, HP, cx, cy ); }
	void draw( Fl_RGB_Image* rgb, int XP, int YP, int WP, int HP, int cx, int cy );
	void DaoWrap_draw( Fl_RGB_Image* rgb, int XP, int YP, int WP, int HP, int cx, int cy ){ Fl_PSfile_Device::draw( rgb, XP, YP, WP, HP, cx, cy ); }
	void draw( const char* s, int n, int x, int y );
	void DaoWrap_draw( const char* s, int n, int x, int y ){ Fl_PSfile_Device::draw( s, n, x, y ); }
	void draw( int angle, const char* str, int n, int x, int y );
	void DaoWrap_draw( int angle, const char* str, int n, int x, int y ){ Fl_PSfile_Device::draw( angle, str, n, x, y ); }
	void draw_image( const uchar* d, int x, int y, int w, int h, int delta, int ldelta );
	void DaoWrap_draw_image( const uchar* d, int x, int y, int w, int h, int delta=3, int ldelta=0 ){ Fl_PSfile_Device::draw_image( d, x, y, w, h, delta, ldelta ); }
	void draw_image_mono( const uchar* d, int x, int y, int w, int h, int delta, int ld );
	void DaoWrap_draw_image_mono( const uchar* d, int x, int y, int w, int h, int delta=1, int ld=0 ){ Fl_PSfile_Device::draw_image_mono( d, x, y, w, h, delta, ld ); }
	void DaoWrap_draw_scaled_image( const uchar* data, double x, double y, double w, double h, int iw, int ih, int D=3, int LD=0 ){ Fl_PSfile_Device::draw_scaled_image( data, x, y, w, h, iw, ih, D, LD ); }
	void DaoWrap_draw_scaled_image_mono( const uchar* data, double x, double y, double w, double h, int iw, int ih, int D=3, int LD=0 ){ Fl_PSfile_Device::draw_scaled_image_mono( data, x, y, w, h, iw, ih, D, LD ); }
	void end_complex_polygon(  );
	void DaoWrap_end_complex_polygon(  ){ Fl_PSfile_Device::end_complex_polygon(  ); }
	void end_job(  );
	void end_line(  );
	void DaoWrap_end_line(  ){ Fl_PSfile_Device::end_line(  ); }
	void end_loop(  );
	void DaoWrap_end_loop(  ){ Fl_PSfile_Device::end_loop(  ); }
	int end_page(  );
	void end_points(  );
	void DaoWrap_end_points(  ){ Fl_PSfile_Device::end_points(  ); }
	void end_polygon(  );
	void DaoWrap_end_polygon(  ){ Fl_PSfile_Device::end_polygon(  ); }
	int DaoWrap_font(  ){ return Fl_PSfile_Device::font(  ); }
	void DaoWrap_font( int face, int size ){ Fl_PSfile_Device::font( face, size ); }
	void gap(  );
	void DaoWrap_gap(  ){ Fl_PSfile_Device::gap(  ); }
	void line( int x1, int y1, int x2, int y2 );
	void DaoWrap_line( int x1, int y1, int x2, int y2 ){ Fl_PSfile_Device::line( x1, y1, x2, y2 ); }
	void line( int x1, int y1, int x2, int y2, int x3, int y3 );
	void DaoWrap_line( int x1, int y1, int x2, int y2, int x3, int y3 ){ Fl_PSfile_Device::line( x1, y1, x2, y2, x3, y3 ); }
	void line_style( int style, int width, char* dashes );
	void DaoWrap_line_style( int style, int width=0, char* dashes=0 ){ Fl_PSfile_Device::line_style( style, width, dashes ); }
	void loop( int x0, int y0, int x1, int y1, int x2, int y2 );
	void DaoWrap_loop( int x0, int y0, int x1, int y1, int x2, int y2 ){ Fl_PSfile_Device::loop( x0, y0, x1, y1, x2, y2 ); }
	void loop( int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 );
	void DaoWrap_loop( int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 ){ Fl_PSfile_Device::loop( x0, y0, x1, y1, x2, y2, x3, y3 ); }
	void margins( int* left, int* top, int* right, int* bottom );
	int not_clipped( int x, int y, int w, int h );
	int DaoWrap_not_clipped( int x, int y, int w, int h ){ return Fl_PSfile_Device::not_clipped( x, y, w, h ); }
	void origin( int x, int y );
	void pie( int x, int y, int w, int h, double a1, double a2 );
	void DaoWrap_pie( int x, int y, int w, int h, double a1, double a2 ){ Fl_PSfile_Device::pie( x, y, w, h, a1, a2 ); }
	void point( int x, int y );
	void DaoWrap_point( int x, int y ){ Fl_PSfile_Device::point( x, y ); }
	void polygon( int x0, int y0, int x1, int y1, int x2, int y2 );
	void DaoWrap_polygon( int x0, int y0, int x1, int y1, int x2, int y2 ){ Fl_PSfile_Device::polygon( x0, y0, x1, y1, x2, y2 ); }
	void polygon( int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 );
	void DaoWrap_polygon( int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3 ){ Fl_PSfile_Device::polygon( x0, y0, x1, y1, x2, y2, x3, y3 ); }
	void pop_clip(  );
	void DaoWrap_pop_clip(  ){ Fl_PSfile_Device::pop_clip(  ); }
	int printable_rect( int* w, int* h );
	void push_clip( int x, int y, int w, int h );
	void DaoWrap_push_clip( int x, int y, int w, int h ){ Fl_PSfile_Device::push_clip( x, y, w, h ); }
	void push_no_clip(  );
	void DaoWrap_push_no_clip(  ){ Fl_PSfile_Device::push_no_clip(  ); }
	void rect( int x, int y, int w, int h );
	void DaoWrap_rect( int x, int y, int w, int h ){ Fl_PSfile_Device::rect( x, y, w, h ); }
	void rectf( int x, int y, int w, int h );
	void DaoWrap_rectf( int x, int y, int w, int h ){ Fl_PSfile_Device::rectf( x, y, w, h ); }
	void rotate( float angle );
	void scale( float scale_x, float scale_y );
	int DaoWrap_size(  ){ return Fl_PSfile_Device::size(  ); }
	int start_page(  );
	int DaoWrap_start_postscript( int pagecount, enum Fl_PSfile_Device::Page_Format format, enum Fl_PSfile_Device::Page_Layout layout ){ return Fl_PSfile_Device::start_postscript( pagecount, format, layout ); }
	void transformed_vertex( double x, double y );
	void DaoWrap_transformed_vertex( double x, double y ){ Fl_PSfile_Device::transformed_vertex( x, y ); }
	void translate( int x, int y );
	void untranslate(  );
	void vertex( double x, double y );
	void DaoWrap_vertex( double x, double y ){ Fl_PSfile_Device::vertex( x, y ); }
	void xyline( int x, int y, int x1 );
	void DaoWrap_xyline( int x, int y, int x1 ){ Fl_PSfile_Device::xyline( x, y, x1 ); }
	void xyline( int x, int y, int x1, int y2 );
	void DaoWrap_xyline( int x, int y, int x1, int y2 ){ Fl_PSfile_Device::xyline( x, y, x1, y2 ); }
	void xyline( int x, int y, int x1, int y2, int x3 );
	void DaoWrap_xyline( int x, int y, int x1, int y2, int x3 ){ Fl_PSfile_Device::xyline( x, y, x1, y2, x3 ); }
	void yxline( int x, int y, int y1 );
	void DaoWrap_yxline( int x, int y, int y1 ){ Fl_PSfile_Device::yxline( x, y, y1 ); }
	void yxline( int x, int y, int y1, int x2 );
	void DaoWrap_yxline( int x, int y, int y1, int x2 ){ Fl_PSfile_Device::yxline( x, y, y1, x2 ); }
	void yxline( int x, int y, int y1, int x2, int y3 );
	void DaoWrap_yxline( int x, int y, int y1, int x2, int y3 ){ Fl_PSfile_Device::yxline( x, y, y1, x2, y3 ); }
};
Fl_PSfile_Device* Dao_Fl_PSfile_Device_Copy( const Fl_PSfile_Device &p );
DaoCxx_Fl_PSfile_Device* DAO_DLL_FLTK DaoCxx_Fl_PSfile_Device_New(  );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Pack  : public DaoCxxVirt_Fl_Group
{
	public:
	DaoCxxVirt_Fl_Pack(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Pack *self, DaoCData *d );
	Fl_Pack *self;
	DaoCData *cdata;
	Fl_Group* as_group( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Pack : public Fl_Pack, public DaoCxxVirt_Fl_Pack
{ 
	public:
   DaoCxx_Fl_Pack( int x, int y, int w, int h, const char* l = 0 ) : Fl_Pack( x, y, w, h, l ){}
	~DaoCxx_Fl_Pack();
	void DaoInitWrapper();
	Fl_Group* as_group(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Pack::draw(  ); }
};
DaoCxx_Fl_Pack* DAO_DLL_FLTK DaoCxx_Fl_Pack_New( int x, int y, int w, int h, const char* l );


Fl_Preferences* DAO_DLL_FLTK Dao_Fl_Preferences_New( Fl_Preferences &parent, const char* group );
Fl_Preferences* DAO_DLL_FLTK Dao_Fl_Preferences_New( Fl_Preferences &parent, int groupIndex );
Fl_Preferences* DAO_DLL_FLTK Dao_Fl_Preferences_New( Fl_Preferences* parent, const char* group );
Fl_Preferences* DAO_DLL_FLTK Dao_Fl_Preferences_New( Fl_Preferences* parent, int groupIndex );
Fl_Preferences* DAO_DLL_FLTK Dao_Fl_Preferences_New( Fl_Preferences::ID id );
Fl_Preferences* DAO_DLL_FLTK Dao_Fl_Preferences_New( Fl_Preferences::Root root, const char* vendor, const char* application );
Fl_Preferences* DAO_DLL_FLTK Dao_Fl_Preferences_New( const Fl_Preferences &_cp0 );
Fl_Preferences* DAO_DLL_FLTK Dao_Fl_Preferences_New( const char* path, const char* vendor, const char* application );


Fl_Plugin_Manager* DAO_DLL_FLTK Dao_Fl_Plugin_Manager_New( const char* klass );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Positioner  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Fl_Positioner(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Positioner *self, DaoCData *d );
	Fl_Positioner *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	void hide( int &_cs  );
	void resize( int &_cs, int x, int y, int w, int h );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Positioner : public Fl_Positioner, public DaoCxxVirt_Fl_Positioner
{ 
	public:
   DaoCxx_Fl_Positioner( int x, int y, int w, int h, const char* l=0 ) : Fl_Positioner( x, y, w, h, l ){}
	~DaoCxx_Fl_Positioner();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	void hide(  );
	void resize( int x, int y, int w, int h );
	void show(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Positioner::draw(  ); }
	void DaoWrap_draw( int _cp0, int _cp1, int _cp2, int _cp3 ){ Fl_Positioner::draw( _cp0, _cp1, _cp2, _cp3 ); }
	int handle( int _cp0 );
	int DaoWrap_handle( int _cp0, int _cp1, int _cp2, int _cp3, int _cp4 ){ return Fl_Positioner::handle( _cp0, _cp1, _cp2, _cp3, _cp4 ); }
};
DaoCxx_Fl_Positioner* DAO_DLL_FLTK DaoCxx_Fl_Positioner_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Progress  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Fl_Progress(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Progress *self, DaoCData *d );
	Fl_Progress *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	void draw( int &_cs  );
	int handle( int &_cs, int event );
	void hide( int &_cs  );
	void resize( int &_cs, int x, int y, int w, int h );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Progress : public Fl_Progress, public DaoCxxVirt_Fl_Progress
{ 
	public:
   DaoCxx_Fl_Progress( int x, int y, int w, int h, const char* l = 0 ) : Fl_Progress( x, y, w, h, l ){}
	~DaoCxx_Fl_Progress();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	void draw(  );
	int handle( int event );
	void hide(  );
	void resize( int x, int y, int w, int h );
	void show(  );
	void DaoWrap_draw(  ){ Fl_Progress::draw(  ); }
};
DaoCxx_Fl_Progress* DAO_DLL_FLTK DaoCxx_Fl_Progress_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Radio_Button  : public DaoCxxVirt_Fl_Button
{
	public:
	DaoCxxVirt_Fl_Radio_Button(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Radio_Button *self, DaoCData *d );
	Fl_Radio_Button *self;
	DaoCData *cdata;
	void draw( int &_cs  );
	int handle( int &_cs, int _cp0 );

};
class DAO_DLL_FLTK DaoCxx_Fl_Radio_Button : public Fl_Radio_Button, public DaoCxxVirt_Fl_Radio_Button
{ 
	public:
   DaoCxx_Fl_Radio_Button( int x, int y, int w, int h, const char* l=0 ) : Fl_Radio_Button( x, y, w, h, l ){}
	~DaoCxx_Fl_Radio_Button();
	void DaoInitWrapper();
	void draw(  );
	int handle( int _cp0 );
};
DaoCxx_Fl_Radio_Button* DAO_DLL_FLTK DaoCxx_Fl_Radio_Button_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Radio_Light_Button  : public DaoCxxVirt_Fl_Light_Button
{
	public:
	DaoCxxVirt_Fl_Radio_Light_Button(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Radio_Light_Button *self, DaoCData *d );
	Fl_Radio_Light_Button *self;
	DaoCData *cdata;
	void draw( int &_cs  );
	int handle( int &_cs, int _cp0 );

};
class DAO_DLL_FLTK DaoCxx_Fl_Radio_Light_Button : public Fl_Radio_Light_Button, public DaoCxxVirt_Fl_Radio_Light_Button
{ 
	public:
   DaoCxx_Fl_Radio_Light_Button( int X, int Y, int W, int H, const char* l=0 ) : Fl_Radio_Light_Button( X, Y, W, H, l ){}
	~DaoCxx_Fl_Radio_Light_Button();
	void DaoInitWrapper();
	void draw(  );
	int handle( int _cp0 );
};
DaoCxx_Fl_Radio_Light_Button* DAO_DLL_FLTK DaoCxx_Fl_Radio_Light_Button_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Round_Button  : public DaoCxxVirt_Fl_Light_Button
{
	public:
	DaoCxxVirt_Fl_Round_Button(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Round_Button *self, DaoCData *d );
	Fl_Round_Button *self;
	DaoCData *cdata;
	void draw( int &_cs  );
	int handle( int &_cs, int _cp0 );

};
class DAO_DLL_FLTK DaoCxx_Fl_Round_Button : public Fl_Round_Button, public DaoCxxVirt_Fl_Round_Button
{ 
	public:
   DaoCxx_Fl_Round_Button( int x, int y, int w, int h, const char* l = 0 ) : Fl_Round_Button( x, y, w, h, l ){}
	~DaoCxx_Fl_Round_Button();
	void DaoInitWrapper();
	void draw(  );
	int handle( int _cp0 );
};
DaoCxx_Fl_Round_Button* DAO_DLL_FLTK DaoCxx_Fl_Round_Button_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Radio_Round_Button  : public DaoCxxVirt_Fl_Round_Button
{
	public:
	DaoCxxVirt_Fl_Radio_Round_Button(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Radio_Round_Button *self, DaoCData *d );
	Fl_Radio_Round_Button *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Radio_Round_Button : public Fl_Radio_Round_Button, public DaoCxxVirt_Fl_Radio_Round_Button
{ 
	public:
   DaoCxx_Fl_Radio_Round_Button( int x, int y, int w, int h, const char* l=0 ) : Fl_Radio_Round_Button( x, y, w, h, l ){}
	~DaoCxx_Fl_Radio_Round_Button();
	void DaoInitWrapper();

};
DaoCxx_Fl_Radio_Round_Button* DAO_DLL_FLTK DaoCxx_Fl_Radio_Round_Button_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Repeat_Button  : public DaoCxxVirt_Fl_Button
{
	public:
	DaoCxxVirt_Fl_Repeat_Button(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Repeat_Button *self, DaoCData *d );
	Fl_Repeat_Button *self;
	DaoCData *cdata;
	void draw( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Repeat_Button : public Fl_Repeat_Button, public DaoCxxVirt_Fl_Repeat_Button
{ 
	public:
   DaoCxx_Fl_Repeat_Button( int X, int Y, int W, int H, const char* l=0 ) : Fl_Repeat_Button( X, Y, W, H, l ){}
	~DaoCxx_Fl_Repeat_Button();
	void DaoInitWrapper();
	void draw(  );
	int handle( int _cp0 );
};
DaoCxx_Fl_Repeat_Button* DAO_DLL_FLTK DaoCxx_Fl_Repeat_Button_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Return_Button  : public DaoCxxVirt_Fl_Button
{
	public:
	DaoCxxVirt_Fl_Return_Button(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Return_Button *self, DaoCData *d );
	Fl_Return_Button *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Return_Button : public Fl_Return_Button, public DaoCxxVirt_Fl_Return_Button
{ 
	public:
   DaoCxx_Fl_Return_Button( int X, int Y, int W, int H, const char* l=0 ) : Fl_Return_Button( X, Y, W, H, l ){}
	~DaoCxx_Fl_Return_Button();
	void DaoInitWrapper();
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Return_Button::draw(  ); }
	int handle( int _cp0 );
};
DaoCxx_Fl_Return_Button* DAO_DLL_FLTK DaoCxx_Fl_Return_Button_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Roller  : public DaoCxxVirt_Fl_Valuator
{
	public:
	DaoCxxVirt_Fl_Roller(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Roller *self, DaoCData *d );
	Fl_Roller *self;
	DaoCData *cdata;
	int format( int &_cs, char* _cp0 );
	void value_damage( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Roller : public Fl_Roller, public DaoCxxVirt_Fl_Roller
{ 
	public:
   DaoCxx_Fl_Roller( int X, int Y, int W, int H, const char* L=0 ) : Fl_Roller( X, Y, W, H, L ){}
	~DaoCxx_Fl_Roller();
	void DaoInitWrapper();
	int format( char* _cp0 );
	void value_damage(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Roller::draw(  ); }
	int handle( int _cp0 );
};
DaoCxx_Fl_Roller* DAO_DLL_FLTK DaoCxx_Fl_Roller_New( int X, int Y, int W, int H, const char* L );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Round_Clock  : public DaoCxxVirt_Fl_Clock
{
	public:
	DaoCxxVirt_Fl_Round_Clock(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Round_Clock *self, DaoCData *d );
	Fl_Round_Clock *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Round_Clock : public Fl_Round_Clock, public DaoCxxVirt_Fl_Round_Clock
{ 
	public:
   DaoCxx_Fl_Round_Clock( int x, int y, int w, int h, const char* l = 0 ) : Fl_Round_Clock( x, y, w, h, l ){}
	~DaoCxx_Fl_Round_Clock();
	void DaoInitWrapper();

};
DaoCxx_Fl_Round_Clock* DAO_DLL_FLTK DaoCxx_Fl_Round_Clock_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Scroll  : public DaoCxxVirt_Fl_Group
{
	public:
	DaoCxxVirt_Fl_Scroll(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Scroll *self, DaoCData *d );
	Fl_Scroll *self;
	DaoCData *cdata;
	Fl_Group* as_group( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Scroll : public Fl_Scroll, public DaoCxxVirt_Fl_Scroll
{ 
	public:
   DaoCxx_Fl_Scroll( int X, int Y, int W, int H, const char* l=0 ) : Fl_Scroll( X, Y, W, H, l ){}
	~DaoCxx_Fl_Scroll();
	void DaoInitWrapper();
	Fl_Group* as_group(  );
	void DaoWrap_bbox( int& _cp0, int& _cp1, int& _cp2, int& _cp3 ){ Fl_Scroll::bbox( _cp0, _cp1, _cp2, _cp3 ); }
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Scroll::draw(  ); }
	int handle( int _cp0 );
	void resize( int _cp0, int _cp1, int _cp2, int _cp3 );
};
DaoCxx_Fl_Scroll* DAO_DLL_FLTK DaoCxx_Fl_Scroll_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Scrollbar  : public DaoCxxVirt_Fl_Slider
{
	public:
	DaoCxxVirt_Fl_Scrollbar(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Scrollbar *self, DaoCData *d );
	Fl_Scrollbar *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Scrollbar : public Fl_Scrollbar, public DaoCxxVirt_Fl_Scrollbar
{ 
	public:
   DaoCxx_Fl_Scrollbar( int X, int Y, int W, int H, const char* L = 0 ) : Fl_Scrollbar( X, Y, W, H, L ){}
	~DaoCxx_Fl_Scrollbar();
	void DaoInitWrapper();
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Scrollbar::draw(  ); }
	int handle( int _cp0 );
};
DaoCxx_Fl_Scrollbar* DAO_DLL_FLTK DaoCxx_Fl_Scrollbar_New( int X, int Y, int W, int H, const char* L );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Secret_Input  : public DaoCxxVirt_Fl_Input
{
	public:
	DaoCxxVirt_Fl_Secret_Input(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Secret_Input *self, DaoCData *d );
	Fl_Secret_Input *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Secret_Input : public Fl_Secret_Input, public DaoCxxVirt_Fl_Secret_Input
{ 
	public:
   DaoCxx_Fl_Secret_Input( int X, int Y, int W, int H, const char* l = 0 ) : Fl_Secret_Input( X, Y, W, H, l ){}
	~DaoCxx_Fl_Secret_Input();
	void DaoInitWrapper();

};
DaoCxx_Fl_Secret_Input* DAO_DLL_FLTK DaoCxx_Fl_Secret_Input_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Select_Browser  : public DaoCxxVirt_Fl_Browser
{
	public:
	DaoCxxVirt_Fl_Select_Browser(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Select_Browser *self, DaoCData *d );
	Fl_Select_Browser *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Select_Browser : public Fl_Select_Browser, public DaoCxxVirt_Fl_Select_Browser
{ 
	public:
   DaoCxx_Fl_Select_Browser( int X, int Y, int W, int H, const char* l=0 ) : Fl_Select_Browser( X, Y, W, H, l ){}
	~DaoCxx_Fl_Select_Browser();
	void DaoInitWrapper();

};
DaoCxx_Fl_Select_Browser* DAO_DLL_FLTK DaoCxx_Fl_Select_Browser_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Shared_Image  : public DaoCxxVirt_Fl_Image
{
	public:
	DaoCxxVirt_Fl_Shared_Image(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Shared_Image *self, DaoCData *d );
	Fl_Shared_Image *self;
	DaoCData *cdata;
	void color_average( int &_cs, Fl_Color c, float i );
	Fl_Image* copy( int &_cs, int W, int H );
	void desaturate( int &_cs  );
	void draw( int &_cs, int X, int Y, int W, int H, int cx, int cy );
	void label( int &_cs, Fl_Menu_Item* m );
	void label( int &_cs, Fl_Widget* w );
	void uncache( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Shared_Image : public Fl_Shared_Image, public DaoCxxVirt_Fl_Shared_Image
{ 
	public:
   DaoCxx_Fl_Shared_Image(  ) : Fl_Shared_Image(  ){}
   DaoCxx_Fl_Shared_Image( const char* n, Fl_Image* img = 0 ) : Fl_Shared_Image( n, img ){}
	~DaoCxx_Fl_Shared_Image();
	void DaoInitWrapper();
	void color_average( Fl_Color c, float i );
	Fl_Image* copy( int W, int H );
	void desaturate(  );
	void draw( int X, int Y, int W, int H, int cx, int cy );
	void label( Fl_Menu_Item* m );
	void label( Fl_Widget* w );
	void uncache(  );
	void DaoWrap_add(  ){ Fl_Shared_Image::add(  ); }
	int DaoWrap_compare( Fl_Shared_Image** i0, Fl_Shared_Image** i1 ){ return Fl_Shared_Image::compare( i0, i1 ); }
	void DaoWrap_update(  ){ Fl_Shared_Image::update(  ); }
};
DaoCxx_Fl_Shared_Image* DAO_DLL_FLTK DaoCxx_Fl_Shared_Image_New(  );
DaoCxx_Fl_Shared_Image* DAO_DLL_FLTK DaoCxx_Fl_Shared_Image_New( const char* n, Fl_Image* img );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Simple_Counter  : public DaoCxxVirt_Fl_Counter
{
	public:
	DaoCxxVirt_Fl_Simple_Counter(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Simple_Counter *self, DaoCData *d );
	Fl_Simple_Counter *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Fl_Simple_Counter : public Fl_Simple_Counter, public DaoCxxVirt_Fl_Simple_Counter
{ 
	public:
   DaoCxx_Fl_Simple_Counter( int x, int y, int w, int h, const char* l = 0 ) : Fl_Simple_Counter( x, y, w, h, l ){}
	~DaoCxx_Fl_Simple_Counter();
	void DaoInitWrapper();

};
DaoCxx_Fl_Simple_Counter* DAO_DLL_FLTK DaoCxx_Fl_Simple_Counter_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Spinner  : public DaoCxxVirt_Fl_Group
{
	public:
	DaoCxxVirt_Fl_Spinner(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Spinner *self, DaoCData *d );
	Fl_Spinner *self;
	DaoCData *cdata;
	Fl_Group* as_group( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Spinner : public Fl_Spinner, public DaoCxxVirt_Fl_Spinner
{ 
	public:
   DaoCxx_Fl_Spinner( int X, int Y, int W, int H, const char* L = 0 ) : Fl_Spinner( X, Y, W, H, L ){}
	~DaoCxx_Fl_Spinner();
	void DaoInitWrapper();
	Fl_Group* as_group(  );
	int handle( int event );
	void resize( int X, int Y, int W, int H );
};
DaoCxx_Fl_Spinner* DAO_DLL_FLTK DaoCxx_Fl_Spinner_New( int X, int Y, int W, int H, const char* L );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Table  : public DaoCxxVirt_Fl_Group
{
	public:
	DaoCxxVirt_Fl_Table(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Table *self, DaoCData *d );
	Fl_Table *self;
	DaoCData *cdata;
	Fl_Group* as_group( int &_cs  );
	void clear( int &_cs  );
	void cols( int &_cs, int val );
	void draw_cell( int &_cs, int context, int R, int C, int X, int Y, int W, int H );
	void rows( int &_cs, int val );

};
class DAO_DLL_FLTK DaoCxx_Fl_Table : public Fl_Table, public DaoCxxVirt_Fl_Table
{ 
	public:
   DaoCxx_Fl_Table( int X, int Y, int W, int H, const char* l=0 ) : Fl_Table( X, Y, W, H, l ){}
	~DaoCxx_Fl_Table();
	void DaoInitWrapper();
	Fl_Group* as_group(  );
	void clear(  );
	void cols( int val );
	void draw_cell( Fl_Table::TableContext context, int R=0, int C=0, int X=0, int Y=0, int W=0, int H=0 );
	void rows( int val );
	void DaoWrap_change_cursor( Fl_Cursor newcursor ){ Fl_Table::change_cursor( newcursor ); }
	long DaoWrap_col_scroll_position( int col ){ return Fl_Table::col_scroll_position( col ); }
	Fl_Table::TableContext DaoWrap_cursor2rowcol( int& R, int& C, Fl_Table::ResizeFlag& resizeflag ){ return Fl_Table::cursor2rowcol( R, C, resizeflag ); }
	void DaoWrap_damage_zone( int r1, int c1, int r2, int c2, int r3 = 0, int c3 = 0 ){ Fl_Table::damage_zone( r1, c1, r2, c2, r3, c3 ); }
	void draw(  );
	void DaoWrap_draw_cell( Fl_Table::TableContext context, int R=0, int C=0, int X=0, int Y=0, int W=0, int H=0 ){ Fl_Table::draw_cell( context, R, C, X, Y, W, H ); }
	int DaoWrap_find_cell( Fl_Table::TableContext context, int R, int C, int& X, int& Y, int& W, int& H ){ return Fl_Table::find_cell( context, R, C, X, Y, W, H ); }
	void DaoWrap_get_bounds( Fl_Table::TableContext context, int& X, int& Y, int& W, int& H ){ Fl_Table::get_bounds( context, X, Y, W, H ); }
	int handle( int e );
	int DaoWrap_handle( int e ){ return Fl_Table::handle( e ); }
	int DaoWrap_is_fltk_container(  ){ return Fl_Table::is_fltk_container(  ); }
	void DaoWrap_recalc_dimensions(  ){ Fl_Table::recalc_dimensions(  ); }
	void DaoWrap_redraw_range( int toprow, int botrow, int leftcol, int rightcol ){ Fl_Table::redraw_range( toprow, botrow, leftcol, rightcol ); }
	void resize( int X, int Y, int W, int H );
	int DaoWrap_row_col_clamp( Fl_Table::TableContext context, int& R, int& C ){ return Fl_Table::row_col_clamp( context, R, C ); }
	long DaoWrap_row_scroll_position( int row ){ return Fl_Table::row_scroll_position( row ); }
	void DaoWrap_scroll_cb( Fl_Widget* _cp0, void* _cp1 ){ Fl_Table::scroll_cb( _cp0, _cp1 ); }
	void DaoWrap_table_resized(  ){ Fl_Table::table_resized(  ); }
	void DaoWrap_table_scrolled(  ){ Fl_Table::table_scrolled(  ); }
};
DaoCxx_Fl_Table* DAO_DLL_FLTK DaoCxx_Fl_Table_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Table_Row  : public DaoCxxVirt_Fl_Table
{
	public:
	DaoCxxVirt_Fl_Table_Row(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Table_Row *self, DaoCData *d );
	Fl_Table_Row *self;
	DaoCData *cdata;
	void cols( int &_cs, int val );
	void draw_cell( int &_cs, int context, int R, int C, int X, int Y, int W, int H );

};
class DAO_DLL_FLTK DaoCxx_Fl_Table_Row : public Fl_Table_Row, public DaoCxxVirt_Fl_Table_Row
{ 
	public:
   DaoCxx_Fl_Table_Row( int X, int Y, int W, int H, const char* l=0 ) : Fl_Table_Row( X, Y, W, H, l ){}
	~DaoCxx_Fl_Table_Row();
	void DaoInitWrapper();
	void cols( int val );
	void draw_cell( Fl_Table::TableContext context, int R=0, int C=0, int X=0, int Y=0, int W=0, int H=0 );
	void clear(  );
	int DaoWrap_find_cell( Fl_Table::TableContext context, int R, int C, int& X, int& Y, int& W, int& H ){ return Fl_Table_Row::find_cell( context, R, C, X, Y, W, H ); }
	int handle( int event );
	int DaoWrap_handle( int event ){ return Fl_Table_Row::handle( event ); }
	void rows( int val );
};
DaoCxx_Fl_Table_Row* DAO_DLL_FLTK DaoCxx_Fl_Table_Row_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Tabs  : public DaoCxxVirt_Fl_Group
{
	public:
	DaoCxxVirt_Fl_Tabs(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Tabs *self, DaoCData *d );
	Fl_Tabs *self;
	DaoCData *cdata;
	Fl_Group* as_group( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Tabs : public Fl_Tabs, public DaoCxxVirt_Fl_Tabs
{ 
	public:
   DaoCxx_Fl_Tabs( int _cp0, int _cp1, int _cp2, int _cp3, const char* s = 0 ) : Fl_Tabs( _cp0, _cp1, _cp2, _cp3, s ){}
	~DaoCxx_Fl_Tabs();
	void DaoInitWrapper();
	Fl_Group* as_group(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Tabs::draw(  ); }
	int handle( int _cp0 );
	void DaoWrap_redraw_tabs(  ){ Fl_Tabs::redraw_tabs(  ); }
};
DaoCxx_Fl_Tabs* DAO_DLL_FLTK DaoCxx_Fl_Tabs_New( int _cp0, int _cp1, int _cp2, int _cp3, const char* s );


Fl_Text_Buffer* DAO_DLL_FLTK Dao_Fl_Text_Buffer_New( int requestedSize, int preferredGapSize );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Text_Display  : public DaoCxxVirt_Fl_Group
{
	public:
	DaoCxxVirt_Fl_Text_Display(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Text_Display *self, DaoCData *d );
	Fl_Text_Display *self;
	DaoCData *cdata;
	Fl_Group* as_group( int &_cs  );
	void draw( int &_cs  );
	int handle( int &_cs, int e );
	void resize( int &_cs, int X, int Y, int W, int H );

};
class DAO_DLL_FLTK DaoCxx_Fl_Text_Display : public Fl_Text_Display, public DaoCxxVirt_Fl_Text_Display
{ 
	public:
   DaoCxx_Fl_Text_Display( int X, int Y, int W, int H, const char* l = 0 ) : Fl_Text_Display( X, Y, W, H, l ){}
	~DaoCxx_Fl_Text_Display();
	void DaoInitWrapper();
	Fl_Group* as_group(  );
	void draw(  );
	int handle( int e );
	void resize( int X, int Y, int W, int H );
	void DaoWrap_absolute_top_line_number( int oldFirstChar ){ Fl_Text_Display::absolute_top_line_number( oldFirstChar ); }
	void DaoWrap_buffer_modified_cb( int pos, int nInserted, int nDeleted, int nRestyled, const char* deletedText, void* cbArg ){ Fl_Text_Display::buffer_modified_cb( pos, nInserted, nDeleted, nRestyled, deletedText, cbArg ); }
	void DaoWrap_buffer_predelete_cb( int pos, int nDeleted, void* cbArg ){ Fl_Text_Display::buffer_predelete_cb( pos, nDeleted, cbArg ); }
	void DaoWrap_calc_last_char(  ){ Fl_Text_Display::calc_last_char(  ); }
	void DaoWrap_calc_line_starts( int startLine, int endLine ){ Fl_Text_Display::calc_line_starts( startLine, endLine ); }
	void DaoWrap_clear_rect( int style, int x, int y, int width, int height ){ Fl_Text_Display::clear_rect( style, x, y, width, height ); }
	void DaoWrap_display_insert(  ){ Fl_Text_Display::display_insert(  ); }
	void DaoWrap_draw(  ){ Fl_Text_Display::draw(  ); }
	void DaoWrap_draw_cursor( int _cp0, int _cp1 ){ Fl_Text_Display::draw_cursor( _cp0, _cp1 ); }
	void DaoWrap_draw_line_numbers( bool clearAll ){ Fl_Text_Display::draw_line_numbers( clearAll ); }
	void DaoWrap_draw_range( int start, int end ){ Fl_Text_Display::draw_range( start, end ); }
	void DaoWrap_draw_string( int style, int x, int y, int toX, const char* string, int nChars ){ Fl_Text_Display::draw_string( style, x, y, toX, string, nChars ); }
	void DaoWrap_draw_text( int X, int Y, int W, int H ){ Fl_Text_Display::draw_text( X, Y, W, H ); }
	void DaoWrap_draw_vline( int visLineNum, int leftClip, int rightClip, int leftCharIndex, int rightCharIndex ){ Fl_Text_Display::draw_vline( visLineNum, leftClip, rightClip, leftCharIndex, rightCharIndex ); }
	int DaoWrap_empty_vlines(  )const{ return Fl_Text_Display::empty_vlines(  ); }
	void DaoWrap_extend_range_for_styles( int* start, int* end ){ Fl_Text_Display::extend_range_for_styles( start, end ); }
	void DaoWrap_find_line_end( int pos, bool start_pos_is_line_start, int* lineEnd, int* nextLineStart )const{ Fl_Text_Display::find_line_end( pos, start_pos_is_line_start, lineEnd, nextLineStart ); }
	void DaoWrap_find_wrap_range( const char* deletedText, int pos, int nInserted, int nDeleted, int* modRangeStart, int* modRangeEnd, int* linesInserted, int* linesDeleted ){ Fl_Text_Display::find_wrap_range( deletedText, pos, nInserted, nDeleted, modRangeStart, modRangeEnd, linesInserted, linesDeleted ); }
	int DaoWrap_get_absolute_top_line_number(  )const{ return Fl_Text_Display::get_absolute_top_line_number(  ); }
	void DaoWrap_h_scrollbar_cb( Fl_Scrollbar* w, Fl_Text_Display* d ){ Fl_Text_Display::h_scrollbar_cb( w, d ); }
	int DaoWrap_longest_vline(  )const{ return Fl_Text_Display::longest_vline(  ); }
	void DaoWrap_maintain_absolute_top_line_number( int state ){ Fl_Text_Display::maintain_absolute_top_line_number( state ); }
	int DaoWrap_maintaining_absolute_top_line_number(  )const{ return Fl_Text_Display::maintaining_absolute_top_line_number(  ); }
	void DaoWrap_measure_deleted_lines( int pos, int nDeleted ){ Fl_Text_Display::measure_deleted_lines( pos, nDeleted ); }
	int DaoWrap_measure_proportional_character( char c, int colNum, int pos )const{ return Fl_Text_Display::measure_proportional_character( c, colNum, pos ); }
	int DaoWrap_measure_vline( int visLineNum )const{ return Fl_Text_Display::measure_vline( visLineNum ); }
	void DaoWrap_offset_line_starts( int newTopLineNum ){ Fl_Text_Display::offset_line_starts( newTopLineNum ); }
	int DaoWrap_position_to_line( int pos, int* lineNum )const{ return Fl_Text_Display::position_to_line( pos, lineNum ); }
	int DaoWrap_position_to_linecol( int pos, int* lineNum, int* column )const{ return Fl_Text_Display::position_to_linecol( pos, lineNum, column ); }
	int DaoWrap_position_to_xy( int pos, int* x, int* y )const{ return Fl_Text_Display::position_to_xy( pos, x, y ); }
	int DaoWrap_range_touches_selection( const Fl_Text_Selection* sel, int rangeStart, int rangeEnd )const{ return Fl_Text_Display::range_touches_selection( sel, rangeStart, rangeEnd ); }
	void DaoWrap_reset_absolute_top_line_number(  ){ Fl_Text_Display::reset_absolute_top_line_number(  ); }
	void DaoWrap_scroll_( int topLineNum, int horizOffset ){ Fl_Text_Display::scroll_( topLineNum, horizOffset ); }
	void DaoWrap_scroll_timer_cb( void* _cp0 ){ Fl_Text_Display::scroll_timer_cb( _cp0 ); }
	int DaoWrap_string_width( const char* string, int length, int style )const{ return Fl_Text_Display::string_width( string, length, style ); }
	void DaoWrap_update_h_scrollbar(  ){ Fl_Text_Display::update_h_scrollbar(  ); }
	void DaoWrap_update_line_starts( int pos, int charsInserted, int charsDeleted, int linesInserted, int linesDeleted, int* scrolled ){ Fl_Text_Display::update_line_starts( pos, charsInserted, charsDeleted, linesInserted, linesDeleted, scrolled ); }
	void DaoWrap_update_v_scrollbar(  ){ Fl_Text_Display::update_v_scrollbar(  ); }
	void DaoWrap_v_scrollbar_cb( Fl_Scrollbar* w, Fl_Text_Display* d ){ Fl_Text_Display::v_scrollbar_cb( w, d ); }
	int DaoWrap_vline_length( int visLineNum )const{ return Fl_Text_Display::vline_length( visLineNum ); }
	int DaoWrap_wrap_uses_character( int lineEndPos )const{ return Fl_Text_Display::wrap_uses_character( lineEndPos ); }
	void DaoWrap_wrapped_line_counter( Fl_Text_Buffer* buf, int startPos, int maxPos, int maxLines, bool startPosIsLineStart, int styleBufOffset, int* retPos, int* retLines, int* retLineStart, int retLineEnd[], bool countLastLineMissingNewLine = true )const{ Fl_Text_Display::wrapped_line_counter( buf, startPos, maxPos, maxLines, startPosIsLineStart, styleBufOffset, retPos, retLines, retLineStart, retLineEnd, countLastLineMissingNewLine ); }
	int DaoWrap_xy_to_position( int x, int y, int PosType = CHARACTER_POS )const{ return Fl_Text_Display::xy_to_position( x, y, PosType ); }
	void DaoWrap_xy_to_rowcol( int x, int y, int* row, int column[], int PosType = CHARACTER_POS )const{ Fl_Text_Display::xy_to_rowcol( x, y, row, column, PosType ); }
};
DaoCxx_Fl_Text_Display* DAO_DLL_FLTK DaoCxx_Fl_Text_Display_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Text_Editor  : public DaoCxxVirt_Fl_Text_Display
{
	public:
	DaoCxxVirt_Fl_Text_Editor(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Text_Editor *self, DaoCData *d );
	Fl_Text_Editor *self;
	DaoCData *cdata;
	void draw( int &_cs  );
	int handle( int &_cs, int e );
	void resize( int &_cs, int X, int Y, int W, int H );

};
class DAO_DLL_FLTK DaoCxx_Fl_Text_Editor : public Fl_Text_Editor, public DaoCxxVirt_Fl_Text_Editor
{ 
	public:
   DaoCxx_Fl_Text_Editor( int X, int Y, int W, int H, const char* l = 0 ) : Fl_Text_Editor( X, Y, W, H, l ){}
	~DaoCxx_Fl_Text_Editor();
	void DaoInitWrapper();
	void draw(  );
	int handle( int e );
	void resize( int X, int Y, int W, int H );
	int DaoWrap_handle_key(  ){ return Fl_Text_Editor::handle_key(  ); }
	void DaoWrap_maybe_do_callback(  ){ Fl_Text_Editor::maybe_do_callback(  ); }
};
DaoCxx_Fl_Text_Editor* DAO_DLL_FLTK DaoCxx_Fl_Text_Editor_New( int X, int Y, int W, int H, const char* l );

Fl_Text_Selection* DAO_DLL_FLTK Dao_Fl_Text_Selection_New();

class DAO_DLL_FLTK DaoCxxVirt_Fl_Tile  : public DaoCxxVirt_Fl_Group
{
	public:
	DaoCxxVirt_Fl_Tile(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Tile *self, DaoCData *d );
	Fl_Tile *self;
	DaoCData *cdata;
	Fl_Group* as_group( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Tile : public Fl_Tile, public DaoCxxVirt_Fl_Tile
{ 
	public:
   DaoCxx_Fl_Tile( int X, int Y, int W, int H, const char* l=0 ) : Fl_Tile( X, Y, W, H, l ){}
	~DaoCxx_Fl_Tile();
	void DaoInitWrapper();
	Fl_Group* as_group(  );
	int handle( int _cp0 );
	void resize( int _cp0, int _cp1, int _cp2, int _cp3 );
};
DaoCxx_Fl_Tile* DAO_DLL_FLTK DaoCxx_Fl_Tile_New( int X, int Y, int W, int H, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Tiled_Image  : public DaoCxxVirt_Fl_Image
{
	public:
	DaoCxxVirt_Fl_Tiled_Image(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Tiled_Image *self, DaoCData *d );
	Fl_Tiled_Image *self;
	DaoCData *cdata;
	void color_average( int &_cs, Fl_Color c, float i );
	Fl_Image* copy( int &_cs, int W, int H );
	void desaturate( int &_cs  );
	void draw( int &_cs, int X, int Y, int W, int H, int cx, int cy );
	void label( int &_cs, Fl_Menu_Item* m );
	void label( int &_cs, Fl_Widget* w );
	void uncache( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Tiled_Image : public Fl_Tiled_Image, public DaoCxxVirt_Fl_Tiled_Image
{ 
	public:
   DaoCxx_Fl_Tiled_Image( Fl_Image* i, int W = 0, int H = 0 ) : Fl_Tiled_Image( i, W, H ){}
	~DaoCxx_Fl_Tiled_Image();
	void DaoInitWrapper();
	void color_average( Fl_Color c, float i );
	Fl_Image* copy( int W, int H );
	void desaturate(  );
	void draw( int X, int Y, int W, int H, int cx, int cy );
	void label( Fl_Menu_Item* m );
	void label( Fl_Widget* w );
	void uncache(  );
};
DaoCxx_Fl_Tiled_Image* DAO_DLL_FLTK DaoCxx_Fl_Tiled_Image_New( Fl_Image* i, int W, int H );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Timer  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Fl_Timer(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Timer *self, DaoCData *d );
	Fl_Timer *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	void hide( int &_cs  );
	void resize( int &_cs, int x, int y, int w, int h );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Timer : public Fl_Timer, public DaoCxxVirt_Fl_Timer
{ 
	public:
   DaoCxx_Fl_Timer( uchar t, int x, int y, int w, int h, const char* l ) : Fl_Timer( t, x, y, w, h, l ){}
	~DaoCxx_Fl_Timer();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	void hide(  );
	void resize( int x, int y, int w, int h );
	void show(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Timer::draw(  ); }
	int handle( int _cp0 );
};
DaoCxx_Fl_Timer* DAO_DLL_FLTK DaoCxx_Fl_Timer_New( uchar t, int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Toggle_Button  : public DaoCxxVirt_Fl_Button
{
	public:
	DaoCxxVirt_Fl_Toggle_Button(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Toggle_Button *self, DaoCData *d );
	Fl_Toggle_Button *self;
	DaoCData *cdata;
	void draw( int &_cs  );
	int handle( int &_cs, int _cp0 );

};
class DAO_DLL_FLTK DaoCxx_Fl_Toggle_Button : public Fl_Toggle_Button, public DaoCxxVirt_Fl_Toggle_Button
{ 
	public:
   DaoCxx_Fl_Toggle_Button( int X, int Y, int W, int H, const char* l=0 ) : Fl_Toggle_Button( X, Y, W, H, l ){}
	~DaoCxx_Fl_Toggle_Button();
	void DaoInitWrapper();
	void draw(  );
	int handle( int _cp0 );
};
DaoCxx_Fl_Toggle_Button* DAO_DLL_FLTK DaoCxx_Fl_Toggle_Button_New( int X, int Y, int W, int H, const char* l );

Fl_Tooltip* DAO_DLL_FLTK Dao_Fl_Tooltip_New();

class DAO_DLL_FLTK DaoCxxVirt_Fl_Tree  : public DaoCxxVirt_Fl_Group
{
	public:
	DaoCxxVirt_Fl_Tree(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Tree *self, DaoCData *d );
	Fl_Tree *self;
	DaoCData *cdata;
	Fl_Group* as_group( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Tree : public Fl_Tree, public DaoCxxVirt_Fl_Tree
{ 
	public:
   DaoCxx_Fl_Tree( int X, int Y, int W, int H, const char* L=0 ) : Fl_Tree( X, Y, W, H, L ){}
	~DaoCxx_Fl_Tree();
	void DaoInitWrapper();
	Fl_Group* as_group(  );
	void draw(  );
	int handle( int e );
	void DaoWrap_item_clicked( Fl_Tree_Item* val ){ Fl_Tree::item_clicked( val ); }
};
DaoCxx_Fl_Tree* DAO_DLL_FLTK DaoCxx_Fl_Tree_New( int X, int Y, int W, int H, const char* L );


Fl_Tree_Item* DAO_DLL_FLTK Dao_Fl_Tree_Item_New( const Fl_Tree_Item* o );
Fl_Tree_Item* DAO_DLL_FLTK Dao_Fl_Tree_Item_New( const Fl_Tree_Prefs &prefs );


Fl_Tree_Item_Array* DAO_DLL_FLTK Dao_Fl_Tree_Item_Array_New( const Fl_Tree_Item_Array* o );
Fl_Tree_Item_Array* DAO_DLL_FLTK Dao_Fl_Tree_Item_Array_New( int new_chunksize );


Fl_Tree_Prefs* DAO_DLL_FLTK Dao_Fl_Tree_Prefs_New(  );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Value_Input  : public DaoCxxVirt_Fl_Valuator
{
	public:
	DaoCxxVirt_Fl_Value_Input(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Value_Input *self, DaoCData *d );
	Fl_Value_Input *self;
	DaoCData *cdata;
	int format( int &_cs, char* _cp0 );

};
class DAO_DLL_FLTK DaoCxx_Fl_Value_Input : public Fl_Value_Input, public DaoCxxVirt_Fl_Value_Input
{ 
	public:
   DaoCxx_Fl_Value_Input( int x, int y, int w, int h, const char* l=0 ) : Fl_Value_Input( x, y, w, h, l ){}
	~DaoCxx_Fl_Value_Input();
	void DaoInitWrapper();
	int format( char* _cp0 );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Value_Input::draw(  ); }
	int handle( int _cp0 );
	void resize( int _cp0, int _cp1, int _cp2, int _cp3 );
};
DaoCxx_Fl_Value_Input* DAO_DLL_FLTK DaoCxx_Fl_Value_Input_New( int x, int y, int w, int h, const char* l );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Value_Output  : public DaoCxxVirt_Fl_Valuator
{
	public:
	DaoCxxVirt_Fl_Value_Output(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Value_Output *self, DaoCData *d );
	Fl_Value_Output *self;
	DaoCData *cdata;
	int format( int &_cs, char* _cp0 );
	void value_damage( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Value_Output : public Fl_Value_Output, public DaoCxxVirt_Fl_Value_Output
{ 
	public:
   DaoCxx_Fl_Value_Output( int x, int y, int w, int h, const char* l=0 ) : Fl_Value_Output( x, y, w, h, l ){}
	~DaoCxx_Fl_Value_Output();
	void DaoInitWrapper();
	int format( char* _cp0 );
	void value_damage(  );
	void draw(  );
	void DaoWrap_draw(  ){ Fl_Value_Output::draw(  ); }
	int handle( int _cp0 );
};
DaoCxx_Fl_Value_Output* DAO_DLL_FLTK DaoCxx_Fl_Value_Output_New( int x, int y, int w, int h, const char* l );


Fl_Widget_Tracker* DAO_DLL_FLTK Dao_Fl_Widget_Tracker_New( Fl_Widget* wi );

class DAO_DLL_FLTK DaoCxxVirt_Fl_Wizard  : public DaoCxxVirt_Fl_Group
{
	public:
	DaoCxxVirt_Fl_Wizard(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_Wizard *self, DaoCData *d );
	Fl_Wizard *self;
	DaoCData *cdata;
	Fl_Group* as_group( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_Wizard : public Fl_Wizard, public DaoCxxVirt_Fl_Wizard
{ 
	public:
   DaoCxx_Fl_Wizard( int _cp0, int _cp1, int _cp2, int _cp3, const char* _cp4 = 0 ) : Fl_Wizard( _cp0, _cp1, _cp2, _cp3, _cp4 ){}
	~DaoCxx_Fl_Wizard();
	void DaoInitWrapper();
	Fl_Group* as_group(  );
};
DaoCxx_Fl_Wizard* DAO_DLL_FLTK DaoCxx_Fl_Wizard_New( int _cp0, int _cp1, int _cp2, int _cp3, const char* _cp4 );

class DAO_DLL_FLTK DaoCxxVirt_Fl_XBM_Image  : public DaoCxxVirt_Fl_Bitmap
{
	public:
	DaoCxxVirt_Fl_XBM_Image(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Fl_XBM_Image *self, DaoCData *d );
	Fl_XBM_Image *self;
	DaoCData *cdata;
	Fl_Image* copy( int &_cs, int W, int H );
	void draw( int &_cs, int X, int Y, int W, int H, int cx, int cy );
	void label( int &_cs, Fl_Menu_Item* m );
	void label( int &_cs, Fl_Widget* w );
	void uncache( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Fl_XBM_Image : public Fl_XBM_Image, public DaoCxxVirt_Fl_XBM_Image
{ 
	public:
   DaoCxx_Fl_XBM_Image( const char* filename ) : Fl_XBM_Image( filename ){}
	~DaoCxx_Fl_XBM_Image();
	void DaoInitWrapper();
	Fl_Image* copy( int W, int H );
	void draw( int X, int Y, int W, int H, int cx=0, int cy=0 );
	void label( Fl_Menu_Item* m );
	void label( Fl_Widget* w );
	void uncache(  );
};
DaoCxx_Fl_XBM_Image* DAO_DLL_FLTK DaoCxx_Fl_XBM_Image_New( const char* filename );


Fl_XPM_Image* DAO_DLL_FLTK Dao_Fl_XPM_Image_New( const char* filename );

class DAO_DLL_FLTK DaoCxxVirt_Flcc_HueBox  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Flcc_HueBox(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Flcc_HueBox *self, DaoCData *d );
	Flcc_HueBox *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	void hide( int &_cs  );
	void resize( int &_cs, int x, int y, int w, int h );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Flcc_HueBox : public Flcc_HueBox, public DaoCxxVirt_Flcc_HueBox
{ 
	public:
   DaoCxx_Flcc_HueBox( int X, int Y, int W, int H ) : Flcc_HueBox( X, Y, W, H ){}
	~DaoCxx_Flcc_HueBox();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	void hide(  );
	void resize( int x, int y, int w, int h );
	void show(  );
	void draw(  );
	void DaoWrap_draw(  ){ Flcc_HueBox::draw(  ); }
	int handle( int _cp0 );
	int DaoWrap_handle_key( int _cp0 ){ return Flcc_HueBox::handle_key( _cp0 ); }
};
DaoCxx_Flcc_HueBox* DAO_DLL_FLTK DaoCxx_Flcc_HueBox_New( int X, int Y, int W, int H );

class DAO_DLL_FLTK DaoCxxVirt_Flcc_ValueBox  : public DaoCxxVirt_Fl_Widget
{
	public:
	DaoCxxVirt_Flcc_ValueBox(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Flcc_ValueBox *self, DaoCData *d );
	Flcc_ValueBox *self;
	DaoCData *cdata;
	Fl_Gl_Window* as_gl_window( int &_cs  );
	Fl_Group* as_group( int &_cs  );
	Fl_Window* as_window( int &_cs  );
	void do_callback( int &_cs, Fl_Widget* o, void* arg );
	void hide( int &_cs  );
	void resize( int &_cs, int x, int y, int w, int h );
	void show( int &_cs  );

};
class DAO_DLL_FLTK DaoCxx_Flcc_ValueBox : public Flcc_ValueBox, public DaoCxxVirt_Flcc_ValueBox
{ 
	public:
   DaoCxx_Flcc_ValueBox( int X, int Y, int W, int H ) : Flcc_ValueBox( X, Y, W, H ){}
	~DaoCxx_Flcc_ValueBox();
	void DaoInitWrapper();
	Fl_Gl_Window* as_gl_window(  );
	Fl_Group* as_group(  );
	Fl_Window* as_window(  );
	void do_callback( Fl_Widget* o, void* arg=0 );
	void hide(  );
	void resize( int x, int y, int w, int h );
	void show(  );
	void draw(  );
	void DaoWrap_draw(  ){ Flcc_ValueBox::draw(  ); }
	int handle( int _cp0 );
	int DaoWrap_handle_key( int _cp0 ){ return Flcc_ValueBox::handle_key( _cp0 ); }
};
DaoCxx_Flcc_ValueBox* DAO_DLL_FLTK DaoCxx_Flcc_ValueBox_New( int X, int Y, int W, int H );

class DAO_DLL_FLTK DaoCxxVirt_Flcc_Value_Input  : public DaoCxxVirt_Fl_Value_Input
{
	public:
	DaoCxxVirt_Flcc_Value_Input(){ self = 0; cdata = 0; }
	void DaoInitWrapper( Flcc_Value_Input *self, DaoCData *d );
	Flcc_Value_Input *self;
	DaoCData *cdata;
};
class DAO_DLL_FLTK DaoCxx_Flcc_Value_Input : public Flcc_Value_Input, public DaoCxxVirt_Flcc_Value_Input
{ 
	public:
   DaoCxx_Flcc_Value_Input( int X, int Y, int W, int H ) : Flcc_Value_Input( X, Y, W, H ){}
	~DaoCxx_Flcc_Value_Input();
	void DaoInitWrapper();
	int format( char* _cp0 );
};
DaoCxx_Flcc_Value_Input* DAO_DLL_FLTK DaoCxx_Flcc_Value_Input_New( int X, int Y, int W, int H );
#endif
